Microsoft has released the first beta of TypeScript 7.1, and it fixes the biggest complaint about the new Go-based compiler: the compiler API is back.

That sounds like a detail for compiler engineers. It is not. The API is the connection that lets editors, linters (tools that flag likely mistakes) and framework tools read TypeScript code. TypeScript 7.0, which shipped in July, replaced the old JavaScript compiler with a much faster Go version but left the API behind. Tools such as Vue’s Volar language server, the code-manipulation library ts-morph and type-aware linting tools either broke or stayed on older releases. Version 7.1 gives them a supported way back in. It also adds something that may matter more: content mappers, a way for Vue and Svelte files to be checked without the usual workarounds.

What changed: TypeScript 7.1 still has no release candidate. Microsoft’s iteration plan targeted an RC for 10 November and a stable release for 24 November. As of 21 November, npm’s latest tag is still 7.0.2, beta is 7.1.0-beta, and there is no 7.1 RC. The beta itself shipped on 20 October, two weeks after the plan’s 6 October target. Microsoft has not announced a new date.

What is the TypeScript compiler API, in plain English?

TypeScript is a programming language built on top of JavaScript. It lets developers describe the shape of their data, so a function that expects a number cannot accidentally receive a string. The compiler reads that code, checks it and produces JavaScript that browsers can run.

Most people never touch the compiler directly. Their editor does. So do tools that rename a variable across a project, flag an unused import or generate code from a schema. All of them need to ask the compiler questions: what is this symbol, where is it defined, what type does it return? The compiler API is that question-and-answer channel.

TypeScript 7.0’s Go rewrite made the compiler much faster, but it removed the channel. Tools that depended on it had three choices: rewrite, wait, or keep users on TypeScript 6.x. That is why the 7.1 beta matters. The API is not a like-for-like copy of the old one. It is split into smaller entry points, typescript/sync, typescript/async, typescript/fs and typescript/ast, so a tool only loads the parts it needs. The compiler also uses reusable snapshots, which let an editor apply a small edit without rebuilding the whole program.

Vue and Svelte move to the front of the queue

Vue and Svelte are frameworks for building user interfaces. Their components live in .vue and .svelte files, which mix HTML, styling and logic in one file. TypeScript’s compiler does not understand those formats, so framework teams have spent years building translators. Vue’s vue-tsc, for example, has to translate a component into something the compiler can read, then map any errors back to the original file.

That works, but it is fragile. A translation is not the real file, and mapping a reported line back to the right place in a component can go wrong. Content mappers replace that step with a formal description. A framework plugin describes the virtual TypeScript document it wants the compiler to see, plus a map from every position in that document back to the real .vue or .svelte file. TypeScript checks the virtual document and reports errors against the original source.

Vue’s language tools have already shipped an alpha built on this design, and the separate vue-tsc binary is no longer needed. Svelte is likely to follow. If the approach holds, checking a component file becomes a first-class operation instead of a wrapper around generated code. Other frameworks with their own file formats have the same option.

How much faster is TypeScript 7.1?

One of the clearest numbers so far comes from Directus, an open-source content platform that migrated its admin app. A write-up of the migration reports type-check times falling from 14.19 seconds to 3.10 seconds across 581 Vue components and 882 TypeScript files. That is roughly 4.6 times faster.

Treat that as a useful signal, not a promise. It is one project, on one machine, with one set of dependencies. The gains will be largest in big codebases where the compiler spends most of its time reading and re-reading files. A small project may save a second or two. The bigger everyday win is likely to be editor responsiveness: faster feedback when you save a file, less waiting for red squiggles to update.

Speed also changes behaviour. When a full type check takes 14 seconds, teams move it to a pre-commit hook or a nightly job. At three seconds, it can run on every save. That is the difference between catching a mistake while you are still thinking about the code and catching it the next morning.

What breaks, and what can wait

The API is back, but the migration is not free. TypeScript 7.1 exposes a new interface, not the old monolithic module. Tools written against the 5.x and 6.x API need to adopt the new entry points. Some already have. Others, especially commercial IDE extensions and enterprise plugins, may not be ready when the stable release arrives.

The risk is uneven. Framework maintainers can ship an alpha in weeks, as Vue has. Larger vendors tend to move on quarterly release cycles, and internal tools may have no owner paying attention. A team that upgrades early could end up with a very fast editor and a broken lint step, or a working build and a code review tool that no longer understands the project.

That is why the safe path is boring. Run the new compiler where a failure is visible and reversible, not where it silently changes what ships.

Where the 7.1 release actually stands

Microsoft’s public iteration plan is the best schedule available, and it is a plan rather than a contract. It lists a beta on 6 October, an RC on 10 November and a stable release on 24 November. The beta arrived on 20 October. The RC date passed with no release. The stable date is still on the calendar, but it has not been revised to reflect the delay.

Milestone Iteration plan Status on 21 November 2026
TypeScript 7.1 beta 6 October 2026 Shipped 20 October 2026
Release candidate 10 November 2026 Not shipped
Stable prep 20 November 2026 No public release event
TypeScript 7.1 stable 24 November 2026 Still the listed target; no new date announced

The npm registry tells the same story. The latest tag points at 7.0.2. The beta tag points at 7.1.0-beta. The rc tag still points at a 7.0 release candidate. Nightly 7.1 builds are still shipping under the next tag; on 21 November, that was 7.1.0-dev.20261121.1. A nightly build is not a release candidate, and installing one in production is a different kind of bet.

The beta announcement said the team would focus on speed and stability, followed by a release candidate “in about a month” and a final release “shortly thereafter.” Counting from 20 October, that points to a candidate in mid-to-late November and a stable release in late November or early December. A stable release on 24 November, three days after this article’s last check and with no RC published, would be unusually quick. Treat the date as a target, not a promise.

Should you try the beta?

If you maintain a framework tool, a linter or an editor extension, yes. A beta is the best time to find gaps before stable, and the new API needs real-world testing.

If you maintain an application, the safer sequence is:

  • Run TypeScript 7.1 in CI first, alongside your current compiler, and compare results.
  • Keep your editor on the previous release until the extensions you rely on support 7.1.
  • Test the tools that depend on the compiler API, not just tsc itself: type-aware ESLint rules, codemods, test runners and build plugins.
  • Pin versions and keep a rollback path. A beta in a production build is a bet, not a default.

Vue teams have an extra check. The new Vue language tools alpha removes vue-tsc, so scripts and CI jobs that call that binary need updating. Confirm the replacement produces the same diagnostics before you delete the old path.

How to track the release yourself

Three sources are enough. The GitHub iteration plan lists the target dates and the open work. The npm registry shows what has actually shipped. The Vue language tools repository shows whether the framework side is ready.

For the registry, one command is enough: npm view typescript dist-tags. If latest still says 7.0.2 and rc points at a 7.0 build, 7.1 has not shipped, whatever a secondary article says. For the plan, watch the issue rather than a countdown post; dates in the table change less often than the discussion around them.

The more important question is not the date but the ecosystem: whether the linting, editing and framework tools you use have caught up. A stable compiler with half your toolchain still on 6.x is not a stable upgrade.

Watch the Vue language tools releases, the Svelte language server and the changelogs of any plugin that reads TypeScript’s syntax tree. Those are the practical signals that 7.1 is ready for everyday work.

The bottom line

TypeScript 7.1 is a repair release with a strategic edge. Restoring the compiler API makes the Go compiler usable by the tools that made TypeScript pleasant to work with. Content mappers go further: they give frameworks a supported way to bring their own file formats into type checking, instead of maintaining private workarounds.

For most developers, the advice is simple. Try it in CI, keep your editor stable, and wait for the plugins you depend on. For Vue and Svelte users, the payoff is worth watching closely: faster checks, better error locations and one less binary in the build. The release date is the least important part of the story, and right now it is also the least certain.

What we added: We updated this article on 21 November with the current release status, checked the npm dist-tags directly, added the iteration-plan table, explained how to verify the release without relying on secondary coverage, and added a section on tracking the ecosystem. The technical explanation of the compiler API, content mappers and the Directus benchmark is unchanged.

Last reviewed: 21 November 2026.

Sources: Microsoft, “Announcing TypeScript 7.1 Beta” (20 October 2026); TypeScript 7.1 iteration plan (GitHub issue 63703); npm registry dist-tags for TypeScript (checked 21 November 2026); TypeScript v7.1-beta release; Directus migration benchmark; Vue Language Tools; InfoQ on the 7.1 beta (6 November 2026).

Have a tip? Email [email protected] or use the contact form and choose Editorial. We do not promise anonymity.