TypeScript 7.1 Brings the API Back
TypeScript 7.0 shipped a fast native compiler in July, but with no API to build tools on. The 7.1 Beta, announced October 20, 2026, restores it in six focused entry points, adds content mappers for Vue, Svelte, and Astro, and makes es2026 a stable target. Here is what changed, what it is faster at, and what to try this week.
Amir Ali Liaqat · Founder & CEO, DesignsToDeploy

On October 20, 2026, the TypeScript team announced the beta of TypeScript 7.1, and the headline is not a new language feature. It is the return of something the native compiler launched without: a programmatic API. TypeScript 7.0, which shipped on July 8, 2026, rewrote the compiler in Go and made it dramatically faster, but it shipped without an API for the tools that build on the compiler. The 7.1 Beta restores that API, adds a plugin point for frameworks that embed TypeScript in other file formats, and makes es2026 a stable target. The release candidate follows in about a month, with the final release shortly after. If your team writes TypeScript every day, this is the release that decides when your toolchain can move to the native compiler.
What 7.0 left out
TypeScript 7.0 was a port, not a redesign: the same compiler logic, rewritten in Go, running as the same tsc command. The team reported it is often around 10 times faster than TypeScript 6.0. But the old API was a JavaScript module that tools loaded directly into their own process, and a compiled Go program cannot be imported that way. So 7.0 shipped with no stable API at all. That left the tools that embed the compiler stranded: Vue's Volar, Svelte and Astro tooling, ts-morph, and type-aware linting all stayed on TypeScript 6. The 7.0 announcement itself said Vue, MDX, Astro, and Svelte projects should stay on TypeScript 6.0 for now. Three months of fast compiles, and the ecosystem that checks your code could not follow. That is the gap 7.1 closes.
The new API, in six pieces
Instead of reviving one monolithic module, 7.1 splits the API into focused entry points, each with a single job. typescript/sync is a synchronous compiler client with compiler options, type-checker, and program APIs; typescript/async is its Promise-based equivalent. typescript/fs provides request-scoped full and layered filesystems, so tools can type-check code that only exists in memory. typescript/ast carries the syntax tree node types and enums such as SyntaxKind and ScriptTarget, typescript/ast/is holds the node type guards, and typescript/ast/factory holds the create and immutable update functions. Around them sits a new idea, the snapshot: a version of all projects and programs at a point in time, which you can update cheaply when a file changes instead of rebuilding the world. One detail matters in practice: API and Program objects are Disposable. You close them explicitly, or declare them with the using keyword, because the garbage collector alone cannot clean up the Go side, and forgetting means a memory leak.
Content mappers: first-class Vue, Svelte, and Astro support
The second big piece is content mappers, a plugin point that lets TypeScript understand files that embed JavaScript or TypeScript inside another format. A .vue file mixes HTML, JavaScript, and CSS; Astro, Svelte, Ember, and MDX files do the same. Volar already made this work in the editor, but command-line type-checkers could not use it, because they integrate with completely different APIs. In 7.1, as the announcement puts it, Volar's core model is now a first-class citizen. A content mapper is registered for a file extension in tsconfig.json and produces a virtual representation of the file, with regions that map back to the original, so error messages and spans stay accurate. Mappers are already prototyped or implemented for Astro, CSS Modules, Ember, MDX, Svelte, and Vue, plus an example for HTML files. Because a mapper is effectively an arbitrary executable that TypeScript dispatches to, running one from the command line needs the explicit --runExternalCode flag. In VS Code, 7.1 works with content mappers once workspace trust and content mapper permissions are granted.
“7.0 gave us speed. 7.1 gives tools something to hold on to.”
Faster and leaner, measured
The 7.1 Beta also brings a long list of compiler optimizations, and the team measured them on five public codebases with four type-checker threads under --noEmit, comparing TypeScript 7.0 against the 7.1 Beta. The biggest win is mui-docs: type-checking fell from 22.2 seconds to 11.9, a 1.9x speedup and 46.6 percent less time, while memory fell from 8,093 MiB to 4,079 MiB, a 49.6 percent reduction. The VS Code codebase went from 21.6 seconds to 17.7, 1.2x faster, with memory down 17.2 percent. Sentry went from 19.6 to 15.1 seconds, t3code-server from 26.5 to 19.1, and bluesky from 4.48 to 3.89 seconds, with memory reductions between 15.8 and 24.6 percent. These are Microsoft's own measurements, so treat them as vendor evidence and measure your own repository before you commit, but the direction is consistent: 7.1 is faster and leaner than the already fast 7.0.
es2026 is now a stable target
TypeScript 7.1 also makes es2026 a stable --target and --lib option. The library additions include Math.sumPrecise, Iterator.concat, JSON.rawJSON and a JSON.parse overload that keeps the original text, Error.isError, Map and WeakMap getOrInsert and getOrInsertComputed, Uint8Array base64 and hex helpers, and Array.fromAsync. Two smaller language features arrive alongside it: import attributes in ambient module declarations, so you can declare a module with a required attribute such as with { type: 'css' } and get an error if an import forgets it, and source phase imports, a proposed ECMAScript feature that lets you import a WebAssembly module as a source object and pass it straight to WebAssembly.instantiate. The esnext library also gains proposed methods including Promise.allKeyed, Iterator.zip, and Iterator.prototype.chunks.
Two things that can break your build
The announcement flags two behavioral changes worth knowing before you upgrade. First, TypeScript 7.1 is stricter about distributive type parameters: inside a conditional type branch, the distributed type parameter is now treated as a new parameter that is a subtype of the original but has no relation to other types constrained to it, so code that relied on the old lenient behavior can now fail with a constraint error. Second, types generated for the DOM in lib.d.ts changed, which can affect type-checking. Neither is a reason to skip the beta, but both are reasons to try it on a branch and read the errors it reports, rather than discovering them in production.
What to do this week
First, install the beta on a branch with npm install -D typescript@beta, and keep production on TypeScript 6 or 7.0 until the release candidate. Second, flip a side project to --target es2026 and see what the new library methods replace. Third, if you maintain tooling for Vue, Svelte, Astro, or MDX, prototype a content mapper for your format while the API is still in beta and the team is asking for feedback. Fourth, run your own --noEmit timings and memory numbers, and compare them with the team's table rather than taking it on trust. The official announcement says the release candidate follows in about a month, with the final release shortly after; the team's public iteration plan targets the candidate for November 10 and the stable release for November 24, though those dates are planning targets and can slip. The beta is the time to find out what 7.1 does to your codebase, while there is still time to report it.
Sources: TypeScript team, Announcing TypeScript 7.1 Beta, by Daniel Rosenwasser (October 20, 2026), read in full. TypeScript 7.0 launch details and the API gap as described in the 7.0 announcement and the team's iteration plan. Release candidate and stable dates per the team's public iteration plan as reported by secondary coverage; the official announcement gives only the relative timing, about a month to the candidate, final shortly after. Performance and memory figures are Microsoft-measured on five codebases, four type-checker threads, --noEmit, TypeScript 7.0 versus 7.1 Beta. All claims observed November 9, 2026.
1 / 5Keep reading

Git 2.56: Safer Conflicts, a Tidier Repo, and Much Faster History
Git 2.56 landed in late September 2026 with one theme: stop the small mistakes that cost teams hours. Here is what changed, from git add --resolved and branch cleanup to merge-base speedups that turn minutes into milliseconds.
Read article
Node 26 Goes LTS: Patch First, Upgrade Smart
On October 28, 2026, Node.js 26 becomes the long-term support release your production apps should run on. Five days earlier, a security release patched Node 22, 24 and 26 together. Here is the timeline, the fixes, and the safe upgrade order.
Read article
VS Code 1.145: Coding Agents That Work While You Sleep
VS Code 1.145 shipped November 4, 2026, turning the editor into an agent host: remote agents you can preview in the Agents window, automations on a five-field cron schedule, and nested sessions that mix harnesses. What changed, what is still preview, and the four moves to set it up today.
Read article