What is tsgo? TypeScript's Go-native compiler vs tsc

tsgo is the command-line entry point for Microsoft's @typescript/native-preview package. It was the public CLI for trying the Go-native compiler before TypeScript 7 stabilized. The current TypeScript Go README now says TypeScript 7.0 RC and later use the tsc command name, and npm reports typescript@7.0.2 as the latest stable package. If you searched for "tsgo" broadly, the practical 2026 answer is therefore: tsgo still names the preview path, while current TypeScript 7 ships the native compiler as tsc.

Fast answers for tsgo searchers

For the broader release path, see the TypeScript 6 and TypeScript 7 Go rewrite guide. For build-pipeline context, compare best TypeScript build tools before changing transpilation or declaration emit.

TL;DR: what tsgo is and when to try it

Use the stable TypeScript 7 tsc command for a current native-compiler trial; do not migrate production CI by swapping tsc for the preview-only tsgo name. Pin TypeScript 6.0.3 only when a compiler API or output-compatibility requirement still blocks the TypeScript 7 native line. Microsoft's announcement showed roughly order-of-magnitude checking improvements across projects such as VS Code, Playwright, TypeORM, date-fns, tRPC, and rxjs, but those are announcement benchmarks, not a guarantee for your repository.

For broad tsgo searchers: the preview command is still available from @typescript/native-preview, but stable TypeScript 7 now exposes the native compiler as tsc. For tsgo vs tsc searchers: compare preview-era tsgo with current native tsc, and compare TypeScript 7 output against a pinned TypeScript 6.0.3 compiler only where compatibility requires it.

Decision matrix: quick tsgo vs tsc choice

Key takeaways

• tsgo means the Go-native preview CLI, distributed as @typescript/native-preview; it is no longer the command name for stable TypeScript 7.
• TypeScript 7.0.2 is now the current npm release. Its package exposes tsc and native platform-binary dependencies, matching the README's TypeScript 7.0 RC-and-later command guidance.
• The headline value is speed, especially for type checking. Microsoft reported order-of-magnitude improvements on several public repositories, including VS Code at 77.8s with current tsc versus 7.5s with the native implementation.
• The language does not change. The safe expectation is the same TypeScript source and type model, with compatibility gaps concentrated in implementation maturity, tooling, API, and workflow support.
• Adoption should be a side-by-side migration, not a flag-day replacement. Use stable TypeScript 7 and its tsc command for the migration path; reserve @typescript/native-preview and tsgo for preview-only comparisons while you validate diagnostics, emit artifacts, project references, editor behavior, and CI performance.

At-a-glance comparison

Benchmark evidence, with the caveat that matters

Microsoft's original native-port announcement reported these examples for checking public codebases:

Those numbers are strong enough to justify a trial, but they should not be copied into your planning as a guaranteed CI reduction. Your result depends on project references, cold versus warm cache, filesystem speed, lockfile state, machine class, framework type-generation steps, and whether your build is actually blocked by TypeScript checking rather than tests, lint, bundling, or package installs.

Package health snapshot

PkgPulse readers usually need the package-level view before changing CI:

Migration notes: the safe CI pattern

Start with version-pinned checks. Installing unpinned typescript now gives TypeScript 7, so a TypeScript 6 compatibility baseline must name 6.0.3 explicitly.

# Stable native TypeScript 7 compiler.
npx -p typescript@7.0.2 tsc --noEmit --pretty false

# Temporary compatibility baseline for the classic TypeScript 6 compiler.
npx -p typescript@6.0.3 tsc --noEmit --pretty false

# Preview CLI only when a preview-specific comparison is required.
npx -p @typescript/native-preview@7.0.0-dev.20260707.2 tsgo --noEmit --pretty false

A conservative rollout looks like this:

1. Pin the TypeScript 7 and TypeScript 6 versions used for the comparison.
2. Run TypeScript 7 tsc --noEmit beside the existing TypeScript 6 check for the packages touched by a pull request.
3. Store wall-clock time, peak memory if available, diagnostics, declaration output, and JavaScript output from both compilers.
4. Diff results across normal feature, dependency, and generated-code changes.
5. Keep TypeScript 6.0.3 for compiler-API consumers, custom transformers, editor defaults, or release output only while a verified compatibility gap remains.
6. Promote TypeScript 7 tsc step by step; use tsgo only for work that specifically targets the preview package.

Where tsgo fits in modern TypeScript stacks

Many teams already use a two-step TypeScript pipeline:

Type checking:  tsc --noEmit
Transpilation:  Vite, SWC, esbuild, Bun, tsup, tsdown, or a framework build

That split is why the native compiler is attractive. If tsc --noEmit is the slow part, TypeScript 7 can be tested without changing how JavaScript bundles are produced. If your bottleneck is framework route generation, lint, test startup, Playwright, or bundling, neither current tsc nor preview tsgo will fix the slowest step.

Related planning guides: TypeScript 6 and the TypeScript 7 Go rewrite, best TypeScript build tools, running TypeScript directly with tsx, ts-node, and Bun, and Bun Build vs Rolldown vs tsdown.

Dependency risk and tooling risk

The hard part of a compiler migration is rarely the first version-pinned tsc --noEmit run. It is the surrounding tooling:

• package managers and lockfiles that need deterministic native binary resolution;
• generated .d.ts and JavaScript release artifacts that must be byte-for-byte safe for packages;
• test runners or bundlers that call compiler APIs rather than only running the CLI;
• IDE settings that must behave consistently across a team;
• project-reference graphs that mix packages with different tsconfig assumptions;
• custom transformers, type-aware lint rules, doc generators, or framework plugins.

If a repo publishes libraries, keep a pinned TypeScript 6.0.3 release check until TypeScript 7 declaration output and downstream consumer tests are validated. If a repo only needs app-level no-emit checks, current TypeScript 7 tsc can graduate sooner.

Methodology and source-backed evidence

This refresh preserves the 2026-07-01 source-ledger audit's GSC row as historical evidence only; current GSC account data was unavailable to this task. Current compiler, package, download, and repository claims were refreshed on 2026-07-28 against the official TypeScript Go README, Microsoft announcement, npm Registry/Downloads APIs, and GitHub repository metadata.

The benchmark table intentionally repeats Microsoft's announcement examples as official announcement benchmarks. It does not claim that every codebase will see the same speedup. The migration recommendation is based on a source-backed parity gate: same repo, same lockfile, same machine class, same TypeScript config, and repeated diagnostic comparisons before promotion.

Source-backed FAQ

Is tsgo the same thing as TypeScript 7?

No. tsgo is the CLI exposed by @typescript/native-preview. The current README says TypeScript 7.0 RC and later use tsc, and npm now lists typescript@7.0.2 as latest.

Does tsgo change TypeScript syntax?

No. The TypeScript language remains TypeScript. The migration risk is implementation maturity and tooling parity, not a new type system.

Can tsgo replace tsc in CI today?

That is no longer the right production migration. Test the stable TypeScript 7 tsc command, compare it with a pinned TypeScript 6.0.3 check, and reserve tsgo for preview-specific experiments.

Should package maintainers use tsgo for publishing?

Package maintainers should test TypeScript 7 declaration emit, project references, and downstream consumers before removing a pinned TypeScript 6.0.3 compatibility check. The stable migration target is TypeScript 7 tsc, not preview tsgo.

Why keep TypeScript 6 installed during a TypeScript 7 migration?

Only keep a pinned 6.0.3 check for a demonstrated compiler API, custom-transformer, editor, or output-compatibility requirement. Unpinned typescript now installs the stable 7.0.2 native line.

Related guides

• TypeScript 6 and the TypeScript 7 Go rewrite
• Best TypeScript build tools
• Bun Build vs Rolldown vs tsdown
• tsx vs ts-node vs Bun for running TypeScript directly
• TypeScript adoption rate in top npm packages

Source notes

Official and live-data sources used for this refresh: Microsoft Dev Blogs, the current microsoft/typescript-go README, npm Registry metadata for typescript and @typescript/native-preview, npm Downloads API last-month windows, and GitHub metadata for microsoft/typescript-go and microsoft/TypeScript. Accessed 2026-07-28. The 2026-07-01 GSC/source-ledger row remains explicitly historical because current account data was unavailable.