Bun just turned type-checking into a runtime feature instead of a side errand. Version 1.4.3 of the JavaScript runtime, released by Oven on October 10, 2026, ships a built-in command called bun check that runs a TypeScript 7 compatible type checker directly inside the runtime binary, with no separate tsc install required. By October 16, 2026, Bun’s own documentation had folded the feature into its core runtime docs, and the team behind it was already gating test runs and production builds on whether a project’s types pass.
The timing matters. Microsoft shipped TypeScript 7.0 on July 8, 2026, finishing a Go-language rewrite of the compiler that the company had been teasing since March 2025 under the internal codename Corsa. Bun’s engineers ported that same Go-based checking logic into their own runtime rather than waiting for the broader ecosystem to catch up, according to Bun’s documentation and reporting from Scrydon. The result is a single executable that can run code, execute tests, bundle a build, and type-check a project without ever shelling out to Node.js or the standard TypeScript package.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What bun check Actually Does
The new bun check command reads a project’s existing tsconfig.json file rather than demanding a separate configuration format, according to Bun’s official documentation, updated October 16, 2026. That detail matters for adoption: teams do not need to maintain two parallel sets of compiler flags, one for their editor and one for Bun’s checker. The command also spreads work across every available CPU core, a structural advantage over the traditionally single-threaded execution model that the JavaScript-based TypeScript compiler has used for most of its history.
Bun is explicit that bun check is a checker, not a full replacement for the TypeScript toolchain. It does not emit declaration files, and it does not replace the editor language service that powers autocomplete and inline errors in VS Code or other editors. What it replaces is the specific, often slow step of validating an entire codebase’s types before a script runs, a test suite executes, or a build ships.
The TypeScript 7 Connection: Project Corsa’s Go Rewrite
To understand why Bun’s move is significant, it helps to understand what TypeScript 7 actually changed. Microsoft’s TypeScript compiler had been written in TypeScript itself (which compiles down to JavaScript) since the language’s earliest days. That self-hosted design made the compiler easy to maintain but slow to run at scale, particularly on large monorepos. Microsoft’s “10x Faster TypeScript” initiative, publicly floated in March 2025 and later associated with the codename Corsa, proposed rewriting the compiler’s core in Go, according to a technical breakdown published on Zenn.
That rewrite shipped as TypeScript 7.0 on July 8, 2026, per a report on ishu.dev. Microsoft’s own published figures for the new Go-based compiler claimed roughly 10 times faster builds, about 8 times faster editor startup, and roughly 50% lower memory use compared with the previous JavaScript-based compiler. One widely cited internal benchmark showed VS Code’s own type-checking step falling from 77.8 seconds under TypeScript 6 to 7.5 seconds under TypeScript 7, a 10.4 times improvement. A separate Playwright benchmark reportedly dropped from 11.1 seconds to 1.1 seconds, close to a 10 times gain. It’s worth being precise about what improved: the Go rewrite speeds up the compiler’s own checking and tooling, not the runtime speed of the JavaScript code TypeScript eventually produces.
Bun’s Performance Claims: 3x to 6.4x Faster, Far Less Memory
Bun’s own benchmark claims, reported October 11, 2026, put bun check between 3 times and 6.4 times faster than running tsc from TypeScript 7 directly, with memory use reduced by a claimed 2.2 times to 4.9 times on Bun’s test projects. Those numbers come from Bun’s own benchmark suite rather than an independent third party, so they should be read as a vendor claim pending outside verification, not as an industry-audited result. Still, the direction of the claim lines up with the broader pattern seen in TypeScript 7 itself: moving checking logic into a compiled, multi-threaded binary consistently outperforms the JavaScript-based tooling it replaces.
This is also where Bun’s long-running pitch to developers converges with Microsoft’s own roadmap. Bun has spent several release cycles positioning itself as the faster alternative to Node.js, a comparison the site has benchmarked directly against Node.js and Deno on raw throughput. Folding a Go-derived type checker into the runtime extends that speed pitch from request handling into the build and test pipeline itself.
Bun 1.4.3’s New Type-Checking Commands
| Command | What It Does | What It Gates |
|---|---|---|
bun check | Type-checks the project using tsconfig.json, parallelized across CPU cores | Nothing on its own; reports errors |
bun run --check | Runs a script, but first validates project types | Script execution |
bun test --check | Runs the test suite only if types pass | Test execution |
bun build --check | Bundles the project only if types pass | Production builds |
That table is the heart of the release. In practice, a team can wire a single flag into existing npm-style scripts and have Bun refuse to run, test, or build a project the moment a type error appears, turning a step that used to live in a separate CI job into a built-in precondition of the runtime itself.
{
"scripts": {
"check": "bun check",
"test": "bun test --check",
"build": "bun build --check ./src/index.ts --outdir ./dist"
}
}Conformance Testing Against 51,210 TypeScript 7 Baseline Tests
Compatibility is the obvious worry with any reimplementation of a compiler’s type-checking rules, and Bun tried to address it head-on. According to reporting from The Code W on October 16, 2026, Bun validated its checker against TypeScript 7.0.2’s own conformance suite, a set of 51,210 baseline tests that Microsoft uses to confirm its compiler behaves correctly across edge cases. Bun said its checker passed the full suite. That is a meaningful claim, since a checker that disagrees with the official compiler on even a small number of edge cases could pass code in CI that later fails when a team runs the real tsc, or the reverse.
It is worth flagging what is not yet independently confirmed. The conformance figure and the speed and memory multiples all trace back to Bun’s own release materials and benchmark projects, as reported by outlets covering the release. No outside lab has published a side-by-side reproduction of those numbers yet, and reporting on this release does not include GitHub star counts, npm or Bun package-manager download figures, or a dated public quote from Bun creator Jarred Sumner or his company, Oven. Those gaps matter for anyone deciding how quickly to trust the claims at face value.
Gating Tests and Builds on Type Correctness
The more consequential design choice here is not the speed claim, it is the gating. Most JavaScript and TypeScript teams already run tsc --noEmit somewhere in CI, but it typically sits as its own pipeline step, separate from the test runner and the build command, and a type failure there does not always stop a developer from running tests locally or shipping a build from their own machine. Bun’s run --check, test --check, and build --check flags move that gate into the commands developers already run every day, which changes the failure mode from “a separate job turned red” to “the command simply won’t execute.”
That is a meaningful behavioral shift for teams that have struggled to get engineers to treat type errors as blocking. It also lines up with a broader trend the site has tracked around TypeScript’s continued gain on plain JavaScript in day-to-day development, where stricter typing discipline has become less of an opt-in style choice and more of an expected baseline.
How This Reshapes CI Pipelines for JavaScript Teams
For teams already standardized on Bun as their runtime, the practical upside is consolidation. A repository that previously needed a package manager, a bundler, a test runner, and a separate type-checking step can now run all four through one binary, with type checking happening in parallel on every available core rather than queued behind a single-threaded process. If Bun’s claimed 3 times to 6.4 times speed multiple holds up under independent testing, that is a direct cut to CI minutes billed by hosted runners, which is often one of the larger line items in a growing engineering org’s tooling budget.
The catch is that this only helps teams already on Bun, or willing to migrate. Projects still anchored to Node.js, Webpack, or a bundler such as the ones compared in the site’s own build-tool benchmarks don’t get this feature by default, and a mid-migration team now has to decide whether to adopt Bun’s checker, keep running the standalone TypeScript 7 compiler, or run both during a transition period to confirm the two agree.
Bun vs Node.js vs Deno: Where the Runtime Race Stands Now
Bun’s pitch has always rested on being the batteries-included alternative to Node.js, bundling a package manager, bundler, and test runner that would otherwise require separate tools such as npm, pnpm, Webpack, and Jest. The site’s own package-manager testing found Bun’s installs dramatically faster than npm in cold-cache scenarios, a gap covered in detail against pnpm and npm. Embedding a TypeScript 7 checker extends that all-in-one argument from installs and bundling into the type system itself, an area where Node.js and Deno have historically relied on the standard, separately installed TypeScript compiler.
Where Node.js Stands
Node.js has no built-in type checker at all. Teams running TypeScript on Node still need to install the TypeScript package separately and wire tsc, or a transpiler such as ts-node or esbuild, into their own scripts and CI jobs. That gives Node.js maximum flexibility to swap in whichever TypeScript version or tool a project prefers, but it also means every project re-solves the same wiring problem Bun now claims to solve out of the box.
Where Deno Stands
Deno has its own built-in TypeScript support, but it works by transpiling and running TypeScript directly without requiring a separate compile step, which is a different value proposition than Bun’s new standalone, parallelized checker that can gate commands independently of execution. Reporting reviewed for this story does not include a fair, like-for-like benchmark of Deno’s or Node’s current type-checking speed against Bun’s new checker, so any claim that Bun now definitively beats either rival on checking speed should be treated as unconfirmed until someone runs that comparison directly.
Runtime Comparison: TypeScript Checking Approach
| Runtime | Type-Checking Approach | Requires Separate tsc Install | Can Gate Tests/Builds Natively |
|---|---|---|---|
| Bun 1.4.3 | Built-in bun check, ported from TypeScript 7’s Go checker | No | Yes (--check flags) |
| Node.js | Relies on the standard, separately installed TypeScript compiler | Yes | No, requires external CI step |
| Deno | Transpiles and runs TypeScript directly at execution time | No (built-in transpiler) | Partial, via separate lint/check commands |
Row by row, the table underlines that each runtime solved a different piece of the TypeScript problem first. Deno solved “can I run TypeScript without a build step.” Bun is now trying to solve “can I also validate and gate on types without a build step,” which is a narrower but arguably more consequential claim for teams that already treat type safety as a release gate.
Why TypeScript Adoption Numbers Make This Urgent
Bun’s bet only pays off if enough of the JavaScript ecosystem has already standardized on TypeScript, and the surveyed data suggests that shift is largely complete. JetBrains reported that 35% of developers used TypeScript in 2024, up from just 12% in 2017, according to its 2024 State of Developer Ecosystem report. Stack Overflow’s 2025 developer survey found that figure climbing further, with 43.6% of respondents reporting TypeScript use, per Stack Overflow’s published 2025 results. The State of JavaScript 2024 survey went a step further on intensity of use rather than raw adoption, finding that 67% of respondents said they now write more TypeScript than plain JavaScript code, according to State of JavaScript’s 2024 usage data.
Read together, those three data points describe a language ecosystem where TypeScript has gone from a minority style choice to the default way most respondents write JavaScript. That is the context in which Bun’s move makes strategic sense: if most of a runtime’s target developers are already writing TypeScript most of the time, then type checking stops being an optional add-on and starts looking like a core runtime responsibility, which is exactly the framing Bun is now pushing with its October 2026 release.
Market Impact: What This Means for the JavaScript Tooling Stack
The immediate market effect is competitive pressure on the broader bundler and build-tool layer. Teams that chose a bundler primarily for speed, as covered in the site’s comparisons of modern build tools, now have a new variable to weigh: whether their chosen stack can match Bun’s claim of parallelized, runtime-native type checking, or whether they will keep running a standalone TypeScript 7 compiler step alongside whatever bundler they already use. For companies maintaining large monorepos, where type-checking time scales with codebase size, even a conservative version of Bun’s claimed speedup, well short of the full 6.4 times figure, could meaningfully shorten CI queues.
There is also a quieter effect on tooling vendors that sell CI optimization as a product. If a runtime can gate builds on type correctness natively, in parallel, without a separate billed CI step, that removes one more reason for teams to pay for third-party caching or parallelization layers specifically built to speed up type checking. It is a small piece of the market, but it is exactly the kind of feature that erodes demand for point solutions over time.
Historical Context: From tsc to Go-Native Compilers
TypeScript’s compiler has been self-hosted since its earliest public releases more than a decade ago, written in TypeScript and compiled down to JavaScript like any other TypeScript project. That design made it easy for the TypeScript team to dogfood its own language, but it also meant the compiler inherited every performance limitation of running on a JavaScript engine: single-threaded execution by default, garbage collection overhead, and slower cold starts compared with a natively compiled binary.
Microsoft’s public pivot toward a Go-based rewrite, teased in March 2025 and shipped as TypeScript 7.0 in July 2026, was framed internally around closing that gap rather than adding new language features. Bun’s October 2026 release is the first major runtime to visibly build on top of that specific rewrite rather than simply waiting for the ecosystem’s existing tools to get faster on their own. It mirrors a pattern the site has tracked elsewhere in developer tooling, including the TIOBE index’s broader October 2026 language rankings, where tooling speed and ecosystem momentum increasingly move together rather than separately.
Predictions: Where Runtime-Embedded Type Checking Goes Next
- Independent benchmarking firms and individual developers will likely attempt to reproduce Bun’s 3x to 6.4x speed claim within weeks, given how easy the comparison is to run on an existing codebase.
- Expect pressure on Node.js and Deno to either integrate a comparable native checker or more clearly document how their existing TypeScript support compares on checking speed, rather than leaving the comparison to vendor claims alone.
- Editor tooling built on the TypeScript language service, including VS Code extensions that rely on its diagnostics, will likely face questions about whether they adopt Bun’s checker or stay tied to the standard TypeScript 7 compiler.
- CI platforms and caching vendors that currently sell type-check acceleration as a feature may need to adjust pricing or positioning if Bun’s native, parallelized approach proves durable at scale.
- Expect continued scrutiny of the 51,210-test conformance claim, since any publicly discovered mismatch between Bun’s checker and the official TypeScript 7 compiler would quickly become a credibility test for the whole feature.
What Teams Should Watch Before Migrating
A Cautious Migration Path
None of this means every team should rush to flip on --check flags across a production pipeline this week. Bun itself describes the feature as a checker, not a full replacement for declaration-file emission or the language service that powers editor autocomplete, so teams with heavy reliance on generated .d.ts files still need the standard toolchain somewhere in the pipeline. The more conservative path many teams are likely to take is running bun check alongside the existing TypeScript 7 compiler for a release cycle or two, comparing results, and only removing the standalone step once the two consistently agree on a given codebase.
Frequently Asked Questions
What is Bun 1.4.3’s bun check feature?
It is a built-in TypeScript type checker inside the Bun runtime, released October 10, 2026, that reads a project’s existing tsconfig.json and checks types using logic ported from TypeScript 7’s Go-based compiler, without requiring a separate tsc install.
How much faster does Bun claim bun check is than tsc?
Bun’s own benchmarks, reported October 11, 2026, claim bun check is between 3 times and 6.4 times faster than tsc from TypeScript 7, with 2.2 times to 4.9 times lower memory use. These are vendor-reported figures, not independently verified.
What is TypeScript 7 and why does it matter here?
TypeScript 7.0, shipped July 8, 2026, is a rewrite of the TypeScript compiler’s core from TypeScript/JavaScript into Go, under a project Microsoft had previously teased as “10x Faster TypeScript” starting in March 2025. Bun’s checker is built on the same underlying technology.
Can bun check replace the TypeScript compiler entirely?
No. Bun describes it as a checker rather than a full replacement. It does not emit TypeScript declaration files and does not replace the language service that editors use for autocomplete and inline diagnostics.
What commands does Bun 1.4.3 add for gating on types?
Three new flags: bun run –check, bun test –check, and bun build –check, which stop a script, test run, or build respectively if the project’s TypeScript types do not pass.
How does this compare to Node.js and Deno?
Node.js has no built-in type checker and relies on a separately installed TypeScript compiler. Deno transpiles and runs TypeScript directly without a build step but does not offer the same native, parallelized, command-gating checker Bun just introduced. No independent head-to-head benchmark across all three currently exists.
Did Bun test its checker against the official TypeScript test suite?
Bun says it validated bun check against TypeScript 7.0.2’s conformance suite of 51,210 baseline tests and passed all of them, according to reporting from The Code W on October 16, 2026. This claim has not yet been independently reproduced by a third party.
Is TypeScript adoption big enough to justify this investment?
Survey data suggests yes. JetBrains found 35% of developers used TypeScript in 2024, up from 12% in 2017. Stack Overflow’s 2025 survey put usage at 43.6%. State of JavaScript’s 2024 survey found 67% of respondents now write more TypeScript than plain JavaScript.
