TypeScript 7 and the Go Port: Faster Builds, Memory and Editor Feedback

Anyone who has used TypeScript for years knows the rhythm. Code gets written, the editor chews on it for a while, TypeScript works out the project, then tsc runs and there's more waiting. In a big monorepo that pause is long enough to fetch coffee. None of this means the tool is badly designed. Its type system and language tooling grew strong enough to make sense of very large codebases, and that's exactly why it became so central to the JavaScript world. But the strength carried a price: as projects expanded, the compiler and language server turned into a performance bottleneck.

TypeScript 7.0 is Microsoft's reply, and the notable thing is that the main change isn't a new operator, keyword or syntax trick. It's the engine underneath. TypeScript's compiler used to be written in TypeScript, a pleasingly recursive arrangement that worked well, though it meant the compiler had to live inside JavaScript's runtime model. For version 7, Microsoft ported the compiler to Go, producing a native implementation built to exploit modern hardware and parallelism.

That's the thing to grasp about this release. TypeScript 7 isn't primarily a new language but a new engine for the language people already write, and that framing explains nearly everything else about it.

The speed numbers

The headline figure is ten times faster. Microsoft's benchmarks show full builds typically running 8 to 12 times faster, depending on the project, and these come from large real-world codebases and not synthetic microbenchmarks.

Build time isn't even the most striking result, because the language server speeds up too. In Microsoft's example using the VS Code codebase, opening a file that contains an error went from roughly 17.5 seconds before the first error appeared to under 1.3 seconds. That's a different working experience, and in big repositories it matters more than trimming a few hundred milliseconds from a production build.

Using every core

Modern machines have many cores, while tsc historically sat on one. TypeScript 7 makes far better use of them: parsing, type checking and emitting can run in parallel where possible. It also adds some experimental switches:

--checkers
--builders
--singleThreaded

The first two give finer control over how parallel work is divided, and --singleThreaded turns parallelism off when needed, for instance when debugging compiler behavior or running in a cramped environment.

Monorepos stand to gain the most. Picture a repository with an apps directory:

apps/
  web/
  admin/
  mobile/

and a packages directory:

packages/
  ui/
  api/
  config/
  utils/
  domain/

TypeScript used to do a huge amount of sequential work across that dependency graph. With version 7, more of it can happen at the same time. So the message isn't merely that the compiler is faster. It's that the compiler can finally use the hardware it runs on.

Memory

Performance isn't just CPU time. Large TypeScript projects can eat several gigabytes of RAM, especially with the language server running next to an editor, a browser, Docker and dev servers. Microsoft's published benchmarks show memory dropping by about 6% to 26% across several large projects:

• Bluesky: around 26% less
• VS Code: around 18% less
• tldraw: around 15% less
• Playwright: around 11% less

Next to ten-times-faster builds that may sound minor, but anyone who has watched laptop memory vanish inside a large monorepo understands the value.

A new language server

Much of TypeScript's appeal never came from tsc anyway. It comes from the editor: completions, hovering for type info, jumping to a definition, listing every reference, renaming a symbol everywhere, errors shown inline and one-click fixes. A large share of what feels like modern JavaScript development rides on that.

TypeScript 7 ships a new language server built on the Language Server Protocol, using the native implementation and multithreading. The team keeps filling in its functionality: code lenses, inlay hints, semantic highlighting, import sorting and unused-import removal have arrived, along with auto-imports, go-to-source-definition and JSX linked editing and tag completions. The goal goes beyond a quicker tsc: the whole loop from typing to feedback gets faster, and that's arguably the bigger win.

Deterministic output under parallelism

One change is less glamorous but technically neat. TypeScript does a lot of internal bookkeeping with types, symbols, unions and declarations. When several workers run concurrently, the order in which internal objects get created can vary, which could change internal IDs and so alter the ordering in generated declarations.

TypeScript 7 handles it by ordering things deterministically from the contents of the internal objects, instead of relying on the order in which they happened to be met. Take this function:

function foo(condition: boolean) {
  return condition ? 100 : 500;
}

It can yield a declaration like this one:

export declare function foo(
  condition: boolean
): 100 | 500;

and the ordering of the union stays stable no matter how the parallel work lands. Most developers won't notice, but this is just the engineering that makes a highly parallel compiler dependable.

Not a feature release

Anyone expecting something like this:

type NewSuperPower<T> = ...

or a big pile of new language features may find TypeScript 7 underwhelming at first. Most of the effort went into infrastructure instead of new type-system capabilities. The team spent years laying a foundation for the next generation of TypeScript, and now it exists. The roadmap points back toward feature work, ergonomics, further performance gains and a new compiler API after 7.0. The release reads better as the start of a new era than as the end of the previous one.

Caveats for tooling authors

This is where things get interesting for people who build tools. TypeScript 7.0 doesn't ship with the old compiler API, and the team expects 7.1 to introduce a new one. That's a big deal because much of the ecosystem doesn't merely run tsc. Linters, framework compilers, language services and build tools talk to TypeScript programmatically.

It's one reason TypeScript 6 and 7 may need to live side by side for now. Microsoft introduced @typescript/typescript6 to ease the transition, so a project can keep version 6 around for tooling that still needs its API while using version 7's compiler separately. A compiler upgrade isn't always as simple as editing one line:

{
  "devDependencies": {
    "typescript": "^7.0.0"
  }
}

In big ecosystems, the compiler is infrastructure, and infrastructure has dependencies.

Another limit affects frameworks and tools that embed TypeScript within their own compile or language-service pipelines. The team names Vue, MDX, Astro, Svelte and Angular workflows as places where support for the new language-service design is still catching up, and again the absent stable programmatic API explains why. A plain React and TypeScript app may move over without much fuss. A sophisticated framework integration, compiler plugin or language-service plugin has a tougher path. It's worth checking before upgrading any big production repository.

TypeScript 6 as the stepping stone

TypeScript 6 was never just the release preceding 7. It was built deliberately as a bridge. Several old compiler options were flagged as deprecated there and are gone entirely in 7, so the team advises cleaning them up before the leap. Stepping through the intermediate version, as shown below, beats treating 7 as a standalone upgrade:

TypeScript 5.x
      ↓
TypeScript 6
      ↓
TypeScript 7

Any deprecation warnings a project produces under TypeScript 6 deserve attention. They're effectively migration notices sent from the future.

Why the feedback loop matters

TypeScript vanishes after compilation, so frontend developers rarely consider it part of the application's runtime. But it strongly shapes the development runtime. Whenever an editor goes through a cycle like this one:

type something
↓
autocomplete appears
↓
you navigate to a definition
↓
you rename a symbol
↓
you save
↓
CI runs
↓
the project gets type-checked

TypeScript takes part each time, and its role grows as applications do. A 100ms lag doesn't matter, a 10-second lag does, a 30-second wait alters how a person works and a five-minute CI type check alters how an entire team works. The main feature of TypeScript 7 therefore isn't ten-fold faster compilation but a shorter gap between writing code and learning whether it's right.

Trying it

For a new project, TypeScript 7 is clearly worth evaluating. For an existing one, a more measured approach fits. Start by installing it as a dev dependency:

npm install -D typescript@7

Then run a type check without emitting:

npx tsc --noEmit

and inspect the results, going through these areas:

1. Compiler errors
2. Deprecated configuration
3. Build tooling compatibility
4. ESLint integration
5. Framework integration
6. IDE behavior
7. CI performance
8. Memory consumption

In a large monorepo, benchmark before and after, using something like:

time npx tsc --build

and compare the output with the current TypeScript version. The final number shouldn't be the only focus. The whole developer experience is what counts.

Rebuilding the foundation

TypeScript 7 stands out in frontend tooling because the team skipped the usual move of adding more features to the existing architecture and instead rebuilt the base. The language didn't need a rethink. The infrastructure did. The timing makes sense too, with larger JavaScript projects, common monorepos, type-safe APIs everywhere, smarter editors, AI coding tools hungry for semantic data and developers expecting near-instant answers. A compiler fast enough for a 2015 application won't necessarily keep up with a 2026 monorepo.

Put simply, the release concedes that the old design worked but modern software outgrew it. Instead of dropping a type system developers already like, the team rebuilt what runs underneath. For that reason the release matters more than its visible feature list implies. It's a base for what TypeScript becomes next as well as a faster tsc. If the promised gains carry across the ecosystem, the most exciting TypeScript features may not even be in 7. They may be the ones that only become practical because 7 is quick enough to build them.

Ten times is the headline. What lies behind it is parallelism, native execution, reduced memory use, a new language server, deterministic compiler output and groundwork for later tooling. To anyone maintaining large TypeScript applications, that's arguably worth more than yet another type utility.