News
'Native' TypeScript 7 Previews in Visual Studio 2026 Insiders
A much more performant TypeScript is now available in the new Visual Studio 2026 Insiders build, capitalizing on speed gains achieved by porting the language compiler to the native Go language.
The performance gains are realized from changing the architecture of TypeScript, which in previous versions required the use of Node.js, a JavaScript runtime that is effectively a software layer between the language and the OS. With the porting to the native Go language, which is compiled into a binary executable that can run on OSes, that extra software layer is removed. The project, unveiled in March, reported up to tenfold gains in performance (see "Microsoft Ports TypeScript to Go for 10x Native Performance Gains").
The native functionality, in preview, was made available in Visual Studio Code in May, and could also be accessed via a command-line interface (CLI), but now it's available in Microsoft's modern revamp of the IDE, (see "Visual Studio 2026 Arrives in Insiders Channel").
Performance Gains and Developer Benefits
Those significant performance improvements are of course central to the native port effort. Microsoft reported that compile times and editor responsiveness are dramatically improved when using the Go-based compiler, citing numbers that show speed gains of 9x to 13x depending on the project size. According to Anders Hejlsberg in the original announcement, "The native implementation will drastically improve editor startup, reduce most build times by 10x, and substantially reduce memory usage."
The following table of benchmark results shows the order-of-magnitude improvements that developers can expect:
| Codebase | Size (LOC) | Current | Native | Speedup |
|---|
| VS Code | 1,505,000 | 77.8s | 7.5s | 10.4x |
| Playwright | 356,000 | 11.1s | 1.1s | 10.1x |
| TypeORM | 270,000 | 17.5s | 1.3s | 13.5x |
| date-fns | 104,000 | 6.5s | 0.7s | 9.5x |
| tRPC (server+client) | 18,000 | 5.5s | 0.6s | 9.1x |
| rxjs (observable) | 2,100 | 1.1s | 0.1s | 11.0x |
These numbers illustrate the practical benefit to developers: opening large projects in an editor is significantly faster, compile times shrink from minutes to seconds, and language service operations like completions, renames, and refactorings become more responsive. "Features that once seemed out of reach are now within grasp," Hejlsberg explained, noting that the native port "will be able to provide instant, comprehensive error listings across an entire project, support more advanced refactorings, and enable deeper insights that were previously too expensive to compute."
Using Native TypeScript in Visual Studio 2026
Developers using the new Visual Studio 2026 Insiders build can now try out these improvements directly. To use the preview in Visual Studio 2026, Microsoft advises editing a project's package.json file to replace the typescript package with @typescript/native-preview. Visual Studio IntelliSense will surface completions for the updated package reference. After that, Microsoft recommends removing the node_modules folder, reinstalling dependencies, and reopening the project. Once configured, developers can verify the compiler in use by opening a TypeScript file and checking the IntelliSense tab of the Output window
Microsoft emphasized that this is an early preview, so some limitations remain. Conflicts may occur if dependencies bring in the older TypeScript version, and not all Visual Studio editor features are supported yet. "Specifically, you are likely to see different code colorization, missing Quick Fix support, and other missing features," the announcement explained. Issues with HTML component files are also possible. Feedback is encouraged through the TypeScript GitHub repository for compiler and language service problems, while IDE-specific issues should be reported via the Visual Studio Developer Community.
More information is available in a FAQ that features items including:
Related to the latter, Microsoft has detailed its plans for the project.
Versioning and Roadmap
Microsoft has made it clear that the new Go-based compiler will become the foundation for TypeScript 7, while the current JavaScript/Node.js-based compiler will continue development as TypeScript 6. The company will maintain both paths for the near future to ensure compatibility and give teams flexibility in adopting the native implementation. "For the sake of clarity, we'll refer to them simply as TypeScript 6 (JS) and TypeScript 7 (native)," Hejlsberg explained, noting that the two tracks will be kept "as closely aligned as possible so that you can upgrade to TypeScript 7 as soon as it meets your requirements, or fall back to TypeScript 6 if necessary."
TypeScript 6 will continue to evolve with new features, deprecations, and breaking changes that set the stage for the transition to the native architecture. TypeScript 7, meanwhile, will focus on achieving feature parity with the existing compiler and then moving beyond it, with performance gains opening the door to more advanced capabilities. Microsoft's principal product manager for TypeScript, Daniel Rosenwasser, noted that "these previews will eventually become TypeScript 7 and will be published nightly so that you can easily try the latest developments on the TypeScript native port effort."
Concurrent Development and Support
The dual-track approach is intended to avoid disruption for developers who depend on specific APIs, legacy configurations, or workflows that may not yet be supported by the native preview. Microsoft stressed that projects will be able to switch to TypeScript 7 as soon as it meets their needs, while still having the option to remain on TypeScript 6 until the native compiler reaches full maturity and widespread adoption. This incremental path also recognizes TypeScript's critical role in the JavaScript ecosystem, where breaking changes can have significant downstream effects.
Support for both versions is part of a longer-term strategy: TypeScript 6 will be maintained and updated until TypeScript 7 and subsequent native releases are considered stable enough to serve as the default. At that point, the native implementation will assume the central role, but Microsoft said it will continue to weigh feedback carefully as the ecosystem adapts to the transition.
Future Work Priorities
While the performance story has dominated the headlines, Microsoft has also laid out priorities for ongoing work. These include:
- Completing missing compiler features such as
--build mode, declaration emit, and downlevel emit targets.
- Expanding editor integration with features like auto-imports, find-all-references, rename, Quick Fix support, and signature help.
- Advancing the new API model, which includes a native Node.js module called
libsyncrpc to enable synchronous communication with the compiler from JavaScript-based clients.
- Iterating on LSP-based editor services to replace the older TSServer protocol and align TypeScript with modern language tooling standards.
As Rosenwasser explained, "Because so much TypeScript API usage today is synchronous, we wanted to make it possible to communicate with this process in a synchronous way." That work is still early, but Microsoft has positioned it as key to ensuring that third-party tools and integrations can adapt smoothly to the new compiler architecture.
Looking ahead, the company plans to keep issuing nightly native previews, with periodic updates highlighting notable milestones. The long-term goal is a seamless transition to TypeScript 7 as the default, while maintaining stability for developers who rely on the existing compiler. Microsoft framed this effort as foundational, not only for improving TypeScript performance at scale, but also for enabling a new generation of developer tools that can take advantage of the speed and responsiveness provided by the native implementation.
Visual Studio 2026 as a Milestone
Bringing the native preview directly into Visual Studio 2026 represents a significant milestone in that transition. Earlier previews through the CLI and Visual Studio Code extension gave early adopters a way to experiment, but integration with Microsoft's flagship IDE signals that the company sees the native compiler as ready for wider developer testing. While still in preview and missing some functionality, its inclusion in Visual Studio 2026 Insiders places the native compiler in front of a much larger audience, accelerating feedback and adoption on the path toward TypeScript 7 becoming the default.
About the Author
David Ramel is an editor and writer at Converge 360.