TypeScript 7.0: the Go compiler lands, and what it means for vue-tsc

TypeScript 7.0 went up on npm on 8 July as version 7.0.2, three weeks after the release candidate (7.0.1-rc) on 18 June. The announcement calls it a native port: the compiler and language service rewritten in Go, kept as close as possible to the old structure so results stay the same, but running as native code with shared-memory multithreading.

For a Vue project, one paragraph of that announcement matters more than the speed tables. Tools that embed TypeScript in their own compilers, Vue's among them, cannot use 7.0 yet. If your project has .vue files, keep typescript on 6.0 and use the wait to prepare, so the later switch is a one-line change. Code without .vue files can move now, as long as none of its tools import typescript as a library.

What shipped

TypeScript 7 lives in the usual typescript package, and npm install -D typescript now gives you the new tsc. The announcement says the port typically runs full builds 8 to 12 times faster, and gives real projects as evidence. The VS Code codebase went from 125.7 seconds on TypeScript 6 to 10.6 seconds, Sentry from 139.8 to 15.7, Playwright from 12.8 to 1.47. Memory use went down too, by 18 percent for VS Code and 26 percent for Bluesky.

Parsing, type checking and emitting now run in parallel. Three new flags control it, and the first two are marked experimental:

• --checkers sets the number of type-checking workers. The default is 4. More can be faster on big machines and costs memory; fewer suits small CI runners.
• --builders sets how many project references build at once under --build. It multiplies with --checkers, so --checkers 4 --builders 4 can mean 16 checkers.
• --singleThreaded turns parallelism off, for debugging or tight environments.

--watch was rebuilt on a Go port of the file watcher from the Parcel bundler. Nightly builds will soon move from @typescript/native-preview back to typescript@next.

What changes from 6.0

The announcement's compatibility rule: code that compiles cleanly on 6.0 with stableTypeOrdering on and no ignoreDeprecations setting should compile identically on 7.0. stableTypeOrdering is a 6.0 flag that makes 6.0 order types the way 7.0 does. "ignoreDeprecations": "6.0" silences the errors 6.0 raises for deprecated options.

7.0 keeps 6.0's new defaults: strict is on, module is esnext, types is [], rootDir is ./ and noUncheckedSideEffectImports is on. It also makes stableTypeOrdering permanent, with no way to turn it off. Every option 6.0 deprecated is now a hard error with no effect. The list includes:

• target: es5 and downlevelIteration
• moduleResolution set to node, node10 or classic (use bundler or nodenext)
• module set to amd, umd, systemjs or none
• baseUrl (make paths relative to the project root instead)
• setting esModuleInterop, allowSyntheticDefaultImports or alwaysStrict to false
• asserts on imports, which must be with
• passing file paths to tsc in a folder that has a tsconfig.json, unless you add --ignoreConfig

Two behaviours change too. Inference from template literal types now splits strings by Unicode code point, so an emoji is one character, not two halves of a surrogate pair. And type checking of JavaScript files with JSDoc was reworked to match .ts files: @enum and Closure-style function types such as function(string): void are no longer understood.

Editor support through the new language server

The new language server (the process behind your editor's red squiggles and completions) speaks the Language Server Protocol, so any editor that supports it can use TypeScript 7. In VS Code there is a dedicated TypeScript 7 extension that becomes the default once installed, and the announcement says support will ship inside VS Code itself in the coming weeks. Visual Studio switches automatically.

The speed-up reaches the editor too. Opening a file with an error in the VS Code repository used to take about 17.5 seconds before the first red squiggle, and now takes under 1.3. The team also reports more than 80 percent fewer failing language server commands, and more than 60 percent fewer crashes, than with 6.0.

In a Vue workspace, switch it off for now: if the TypeScript 7 extension is active, run Disable TypeScript 7 Language Server from the command palette to go back to 6.0. The next section explains why.

vue-tsc cannot run on TypeScript 7 yet

The announcement says that Vue, MDX, Astro and Svelte workflows will likely not be able to use TypeScript 7 yet. Volar, the engine under Vue's tooling, embeds TypeScript through its programmatic API, and 7.0 does not have a stable one. The announcement's advice: "Projects using Vue, MDX, Astro, Svelte, and others will need to continue using TypeScript 6.0 for now."

vue-tsc is the command that type-checks .vue files, and it is what npm run type-check runs in a create-vue project. Version 3.3.7 was published on 8 July, about twelve hours before TypeScript 7.0.2. Its changelog, from 3.3.0 in May to 3.3.7, does not mention TypeScript 7 at all.

The peer range is typescript >=5.0.0, so npm installs 7.0 next to it without a warning. Then the type check fails:

npm install -D typescript@latest
npx vue-tsc --build
# Error [ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath './lib/tsc' is not
# defined by "exports" in node_modules/typescript/package.json

vue-tsc works by loading TypeScript's own lib/tsc file and patching it so it understands .vue files. The 7.0 package no longer exposes that file. Its exports map offers only a version stub and some unstable/* entries.

The side-by-side setup from the announcement, which aliases typescript to the new @typescript/typescript6 compatibility package, does not rescue vue-tsc either. That package's lib/tsc.js is a one-line shim that requires the real file from another package, and vue-tsc 3.3.7 stops with Error: Failed to locate tsc module path from shim.

Pin TypeScript to 6.0 in Vue and Nuxt projects

What works is the plain 6.0 package. vue-tsc 3.3.7 on TypeScript 6.0.3, the latest 6.x release, type-checks .vue files exactly as before:

{
  "devDependencies": {
    "typescript": "~6.0.3",
    "vue-tsc": "^3.3.7"
  }
}

The tilde allows 6.0 patch releases and nothing above them. create-vue 3.22.4 already scaffolds "typescript": "~6.0.0", so a new project is safe. Three things can still pull in 7.0:

• The one-line install in the vue-tsc README, npm install vue-tsc typescript --save-dev, which since 8 July installs 7.0.2.
• nuxi typecheck in a Nuxt project. It runs vue-tsc, so the same rule applies, and when typescript or vue-tsc is not installed it gets them for you without a version, which for typescript now means 7.0.2. Install both yourself, with the ranges above, before the first run.
• Dependency bots that open a "bump typescript to 7" pull request. Close that pull request for now.

Prepare for the switch now

The useful work for a Vue project this summer is to make the eventual switch boring. Since 7.0 promises identical results for code that is clean on 6.0 under two conditions, meet both now:

1. Remove ignoreDeprecations from every tsconfig file and fix what it was hiding. Projects scaffolded with create-vue before 3.12.2 (November 2024) start with "baseUrl": "." next to paths, and 6.0 rejects it. Delete that line: without it, paths entries resolve from the folder of the tsconfig file that declares them, which is where "baseUrl": "." pointed anyway.
2. Turn on stableTypeOrdering once, run your type check, and fix any new errors, usually with an explicit type argument or annotation where inference used to get lucky. The 6.0 announcement warns it can slow checking by up to 25 percent, so turn it off again afterwards.

In a create-vue project, the flag goes in tsconfig.app.json, the config for the code under src/:

{
  "extends": "@vue/tsconfig/tsconfig.dom.json",
  "compilerOptions": {
    "stableTypeOrdering": true
  }
}

The snippet shows only the added option; keep the rest of your file. Then run npm run type-check.

Plain TypeScript code with no .vue files has no reason to wait, unless it uses a tool that needs the API, such as typescript-eslint, which the announcement names. A Node script folder or a shared types package in a monorepo can move to 7.0 and its --checkers flag today, while the Vue app next to it stays on 6.0.

What has to happen before a Vue app moves

TypeScript has to ship the new API it expects in 7.1, and the Vue language tools have to adopt it. The announcement calls the gap "a point-in-time issue" and says the team will work with the maintainers of these projects, but it gives no date. TypeScript usually ships a feature release every three to four months, and the team says it expects that rhythm to continue.

In a Vue project, typescript follows vue-tsc, not the other way round. So watch the vue-tsc changelog, not the TypeScript blog. The day a release says it supports TypeScript 7, change the tilde line and run the type check.