TypeScript 7.1 Beta Lands With a Faster, Leaner Compiler

TypeScript 7.1 beta doesn’t rewrite your type system – it rewrites your coffee break. Microsoft’s team shaved type-checking time nearly in half on a real-world codebase, and that single fact changes how you should think about upgrading. Announced on October 20th, 2026, and installable right now with npm install -D typescript@beta, this release is less about flashy new syntax and more about making the compiler itself leaner and faster, with a handful of preview features that hint at where the language is headed next.

Is TypeScript 7.1 faster than previous versions?

Image: Microsoft Dev Blogs / TypeScript Team

Yes, substantially so on larger codebases, though the gains vary by project. On the mui-docs codebase, noEmit type-checking time dropped from 22.2 seconds to 11.9 seconds – a 1.9x speedup – while memory usage fell nearly in half, from 8,093 MiB to 4,079 MiB. That’s the kind of number that used to require buying a faster laptop. Now it’s a software update.

The gains aren’t universal. Codebases like vscode and sentry saw more modest 1.2x to 1.3x improvements, which still matters if you’re running type-checks on every commit in CI. Smaller wins compound across hundreds of builds a day. Think of it like a delivery company trimming a few minutes off every route – unremarkable on a single trip, transformative across a whole fleet. For teams stuck watching a spinning cursor during tsc --noEmit, even the conservative end of that range buys back real time.

Microsoft’s benchmarks ran tsc --noEmit against the full checkout of each project, averaged over multiple runs, on a fixed hardware configuration – not a single cherry-picked pass. That methodology matters because type-checking time is notoriously sensitive to disk cache state, project references, and whether skipLibCheck is enabled. If you want a fair read on your own codebase, don’t just time one run. Clear the TypeScript build cache (tsc --build --clean if you use project references), run noEmit three or four times to let the OS file cache warm up, and compare the median – not the first or best result. Do this locally and in CI separately, since CI runners typically have cold caches and different CPU allocations than a developer’s laptop, which can mask or exaggerate the real-world gain.

What’s new in TypeScript 7.1’s import attributes feature?

TypeScript 7.1 lets ambient module declarations scope their typing to specific import attributes, not just file extensions. You can now write declare module "*" with { type: "css" } and TypeScript will apply that typing only when the import actually carries that attribute.

Here’s the before-and-after. Previously, you’d declare types based on wildcard file patterns – one block for .txt, another for .md, even when both should behave identically at runtime. After this release, if two import types share a runtime behaviour, they share a declaration: declare module "*" with { type: "text" } covers both, no duplication required. Import attributes themselves aren’t new – they tell a runtime or bundler how to interpret an import, with type: "json" parsing to an object, the proposed type: "text" returning a plain string, type: "bytes" returning a Uint8Array, and type: "css" returning a CSSStyleSheet in browsers. What’s new is that TypeScript’s static types can now follow that distinction instead of papering over it.

The myth worth busting here: you might think attribute-scoped declarations are a minor convenience. They’re actually a correctness fix. Bundlers that default to CSS Modules unless you specify type: "css" were previously invisible to the type checker – it had no way to model that the same file path could behave two different ways depending on an attribute. Miss a required attribute, like with { type: "text" }, and older TypeScript would silently accept the import. Now it flags the gap as an error, which is exactly the kind of mistake you want caught at compile time, not in a production console log.

Support across the ecosystem is uneven, and that’s the catch. Import attribute syntax at the JavaScript level requires Node.js 22.x or newer, or a bundler that implements the proposal – Webpack 5 and Rollup 4 both parse with { type: ... } natively, but older Vite builds and some Babel configurations without the @babel/plugin-syntax-import-attributes plugin will choke on the syntax entirely, type-checking be damned. Editor support is similarly patchy: VS Code’s built-in TypeScript integration picks this up as soon as you point it at the 7.1 beta via "typescript.tsdk" in workspace settings, but other editors relying on a bundled or older language server won’t surface the new diagnostics until their TypeScript dependency is bumped. Check your bundler’s changelog for import attribute support before you restructure any ambient declarations around it.

What else is new in TypeScript 7.1 Beta?

Beyond import attributes, the beta ships source phase imports (import source), stable --target es2026 support, and new standard library methods including Promise.allKeyed and Iterator.zip. None of these are headline features on their own, but together they read as a compiler quietly catching up to where JavaScript’s standards track has already moved.

The more structurally interesting addition is a new modular API surface: typescript/sync, typescript/async, typescript/fs, and typescript/ast. These expose snapshots and content mappers capable of producing virtual TypeScript representations of non-TypeScript files – think Vue single-file components, where template, script and style blocks all live in one file but only some of it is actually TypeScript. Tooling authors have hacked around this for years with bespoke parsers; a first-party API for it is overdue, in the same way IDEs spent a decade building ad hoc workarounds for JSX before TypeScript absorbed it directly.

Here’s roughly what reaching into that surface looks like for a tooling author mapping a .vue file’s <script> block to a virtual TypeScript file:

import { createSnapshot } from "typescript/fs";
import { createContentMapper } from "typescript/ast";

const snapshot = createSnapshot(filePath, fileContents);
const mapper = createContentMapper({
  extract: (source) => source.match(/<script.*?>([\s\S]*?)<\/script>/)?.[1] ?? "",
  virtualFileName: filePath.replace(".vue", ".vue.ts"),
});

const virtualFile = mapper.map(snapshot);
// virtualFile now behaves like a real .ts file to the language service -
// hover, go-to-definition and diagnostics all work against it directly.

That’s a simplified sketch rather than a drop-in snippet, but it shows the shape: instead of shelling out to a custom parser and stitching results back together, the mapper produces something the TypeScript language service treats as native. Editor plugin authors building Vue, Svelte or Astro support are the obvious first adopters here, not day-to-day application developers.

Head-to-head: speed gains versus new syntax

The performance work is the safer bet to adopt immediately, because it changes nothing about your code – just how fast the compiler chews through it. Import attributes and the modular API, by contrast, ask you to opt in deliberately: rewrite ambient declarations, or build tooling against the new typescript/ast surface. One is a free upgrade; the other is a design decision.

If your pain point is CI minutes or a laptop fan that never stops spinning, install the beta today – npm install -D typescript@beta – and measure your own noEmit times before committing further. If you’re maintaining type definitions for libraries with CSS Modules, JSON, or similarly attribute-dependent imports, start sketching how attribute-scoped declarations simplify your .d.ts files, but hold off on shipping that rework until general availability. Betas are for benchmarking and planning, not for production type definitions you can’t easily unwind.

Upgrade checklist

• Install the beta in a throwaway branch: npm install -D typescript@beta. Don’t touch your lockfile’s committed version yet.
• Benchmark fairly: clear your build cache, run tsc --noEmit three to four times locally and separately in CI, and compare medians rather than a single pass.
• Check your bundler’s import attribute support: Webpack 5 and Rollup 4 are ready; verify your Vite or Babel config explicitly before rewriting any ambient declarations.
• Confirm editor support: in VS Code, point typescript.tsdk at the beta’s lib folder; in other editors, check whether the bundled language server has been updated to 7.1.
• Hold off on shipping scoped declare module rewrites: sketch them now, merge them once 7.1 reaches general availability.
• Leave typescript/ast and the modular API to tooling authors: unless you’re building editor or framework integrations, there’s nothing here to adopt yet.
• Re-run your benchmark after upgrading real dependencies: type-checking speed on a clean npm install -D typescript@beta can shift once transitive @types packages catch up to 7.1.

Source: https://devblogs.microsoft.com/typescript/announcing-typescript-7-1-beta/