Bun 1.4.3 bun check: 6.4x Faster Than tsc [2026]

Bun shipped version 1.4.3 on October 10, 2026, and buried inside the release notes is a feature that has JavaScript and TypeScript teams rethinking their build pipelines. The command is called bun check, a type checker built directly into the Bun runtime, and the Bun team says it runs three to six times faster than Microsoft’s own tsc compiler on the same codebases. Ten days later, Microsoft answered with its own move, announcing the TypeScript 7.1 Beta on October 20. Together the two releases mark one of the sharper skirmishes yet in a year defined by toolchain speed wars.

For a developer audience that has watched build times become a recruiting pitch and a cost-center line item at once, the timing is not a coincidence. Bun check vs tsc is now a live question in standups and pull request threads, not just a benchmark chart on a blog. This piece walks through what actually shipped, what the numbers mean, where the claims come from, and what is likely to happen next across the JavaScript and TypeScript toolchain.

Google · Preferred Sources

Don't miss new tech stories on Google

Add TrendinTech once in the Google app and our stories appear in your news suggestions.

Add Now

What Bun 1.4.3 Changed on October 10

Bun 1.4.3 is a routine-looking point release that turns out to carry an unusually consequential feature. According to the official Bun v1.4.3 announcement, the update adds bun check, updates bundled root certificates to NSS 3.128 with new SECOM and Telia TLS roots, moves the Alpine Docker image to Alpine 3.24, and introduces Bun.FetchSession, which lets developers set separate TLS, proxy, keep-alive, and connection-pool behavior for groups of outbound requests. The release was authored by Jarred Sumner, Bun’s original creator.

None of those changes individually would be news. What makes 1.4.3 stand out is that Bun, a project that started as a JavaScript runtime and bundler, now ships its own TypeScript type checker as a built-in command rather than a wrapper around Microsoft’s tooling. That is a different kind of move than the performance tuning Bun has done in past releases, and it puts Bun in more direct competition with the TypeScript project itself rather than only with Node.js and npm.

Inside bun check: A Type Checker Built Into the Runtime

bun check reads an existing tsconfig.json file, so projects do not need a separate configuration format to adopt it. The Bun team describes the command plainly: “It reads your tsconfig.json, reports the same errors as tsc, and uses every CPU core,” according to the official Bun v1.4.3 blog post. That last detail, parallel use of every available CPU core, is where most of the claimed speed advantage comes from, since the standard tsc compiler has historically run its type-checking pass in a single thread.

Built on a Port of typescript-go

Bun’s checker is not a reimplementation of TypeScript’s type system from scratch. It is built on a port of typescript-go, the native rewrite of the TypeScript compiler that Microsoft itself has been developing as the foundation of TypeScript 7. In other words, Bun did not try to out-engineer TypeScript’s type-checking rules. It took the same native-speed foundation Microsoft built, wrapped it inside Bun’s own CLI, and added Bun’s parallel execution model on top.

Wired Into bun run, bun test, and bun build

The feature is not limited to a standalone command. As of the October 10 release, type checking can gate other Bun workflows through a --check flag, meaning bun run, bun test, and bun build can all fail fast on a type error before doing further work. For teams that already run everything through Bun, that collapses what used to be a separate CI step into the same command they were already running.

$ bun check
Found 1 error in 1 file, checked 2 files [14.00ms]

That sample output, taken from Bun’s own documentation, illustrates the pitch in miniature: a small project checked in milliseconds rather than seconds.

The Numbers Bun Is Publishing

Bun’s own benchmark page, run on a 16-core Apple silicon Mac according to the release notes, backs up the headline figure. The Bun team states directly: “It’s 3x to 6.4x faster than tsc 7.0.2, on a 16-core Apple silicon Mac,” and adds that bun check “is an incredibly fast TypeScript type checker that passes 100% of TypeScript 7.0.2’s conformance test suite,” per the Bun v1.4.3 release notes. The conformance claim is specific: Bun says it passed all 51,210 tests in the TypeScript 7.0.2 conformance suite, matching output byte for byte.

Bun’s published benchmarks, run on a Linux x64 machine with an AMD EPYC 9R14 64-vCPU processor and reported as medians of three runs, point to real workloads rather than synthetic microbenchmarks. On a Nuxt project, Bun reports bun check finishing in 0.27 seconds against 0.80 seconds for tsc, a roughly 3x gap, while using 0.51GB of memory against 1.14GB for tsc, a 2.2x reduction. Those are vendor-published numbers rather than independently reproduced ones, a distinction worth holding onto as adoption spreads.

Metric	tsc 7.0.2	bun check	Reported gap
Nuxt project type-check time	0.80s	0.27s	3x faster
Nuxt project peak memory	1.14GB	0.51GB	2.2x less memory
Best-case speed claim (Bun benchmark set)	baseline	up to 6.4x	3x to 6.4x faster
TypeScript 7.0.2 conformance tests passed	51,210 baseline	51,210 matched byte for byte	100% match
Idle CPU use (Elysia server, post-load)	higher baseline	197ms to 21ms over 2 idle minutes	67% to 89% less CPU

All figures in that table come from Bun’s own October 10 benchmark publication and should be read as the vendor’s best-case measurements rather than a third-party audit.

What bun check Does Not Replace

The limitation that matters most is also the simplest one. bun check performs type checking, full stop. It does not emit JavaScript output and it does not generate .d.ts declaration files. Projects that need a compiled output, which is most published npm packages and many libraries, still need tsc or another build step somewhere in the pipeline. That means bun check is best understood as a faster gate for catching type errors early, not a drop-in replacement for the compiler itself.

That scope limitation is also why the comparison to Microsoft’s broader TypeScript 7 effort, detailed in TrendinTech’s coverage of the TypeScript 7.1 Beta, is not really an apples to apples rivalry. Microsoft is rebuilding the entire compiler toolchain, compilation and emission included, on native code. Bun built one fast piece of that toolchain, type checking, into its own CLI.

Idle CPU and Memory: The Server-Side Pitch

Bun 1.4.3’s performance claims are not limited to type checking. The release notes report that idle servers running on Bun use 67% to 89% less CPU and hold 6% to 11% less memory than before, with one cited example showing an Elysia server’s post-load CPU usage falling from 197 milliseconds to 21 milliseconds across two idle minutes. Bun also reports up to a 2.7x improvement in large HTTP responses inside node:http and Bun.serve, achieved by batching responses over 16KB into a single write per tick instead of up to sixteen separate writes.

For infrastructure teams running Bun in production, that idle-efficiency claim matters as much as the type-checking story, since cloud compute bills are frequently driven by baseline resource consumption rather than peak load. It is also a pattern worth watching alongside broader cloud cost conversations, including the FinOps questions raised in coverage of PostgreSQL 19’s delayed release, where tooling changes and resource efficiency have become tied together across the modern backend stack.

Scrydon’s Field Test: 104 Projects, One Mismatch

Independent validation of vendor benchmarks is always the harder part of a story like this, and one of the clearer early data points comes from the engineering team at Scrydon, which moved its monorepo type-check gate to Bun 1.4.3 shortly after release. The team reported: “Across 104 TypeScript projects it matched tsc byte for byte in 103,” according to Scrydon’s October 12 writeup. That is a strong, though not perfect, match rate, and it lines up closely with Bun’s own claimed conformance numbers.

Scrydon’s measured performance gains were substantial. The same report states: “A cold check of the whole repository fell from 124.9 s to 51 to 68 s, peak memory fell by about a third, and an entire build phase disappeared.” That is a real-world case roughly in line with, though somewhat more modest than, Bun’s own best-case 6.4x figure, which is a useful reminder that vendor benchmarks tend to represent favorable conditions rather than typical ones.

TypeScript 7.1 Beta Lands Ten Days Later

Microsoft’s response, if it can be called that, arrived on October 20 with the announcement of TypeScript 7.1 Beta. The beta adds stable support for the es2026 target and library setting, and Microsoft said the next phase of work would focus on stability, speed, and developer feedback, with a release candidate expected roughly a month out and a stable release to follow. TypeScript’s own project tracker lists a planned stable date, though that remains a target rather than a confirmed release.

TypeScript 7’s broader rewrite is itself a native-code overhaul, and Microsoft has said that foundation makes TypeScript roughly ten times faster than TypeScript 6 thanks to native code speed and shared memory parallelism, a claim covered in more depth in TrendinTech’s prior reporting on the TypeScript 7.1 Beta release. Bun’s comparison baseline for its own benchmarks is TypeScript 7.0.2, the stable release that preceded the 7.1 beta, which means Bun is measuring itself against an already much faster version of TypeScript than the 6.x generation most teams were using a year ago.

Bun vs tsc vs TypeScript-Go: Where Each Tool Fits

With three overlapping but distinct tools now circulating, developer teams need a clearer mental model of what each one is actually for. The table below lays out the practical differences as they stand in October 2026.

Tool	Maintainer	Current version	Primary job	Emits JS or .d.ts files
tsc	Microsoft / TypeScript project	7.0.2 stable, 7.1 in beta	Full compile, type check, emit output	Yes
bun check	Bun / Oven	Shipped in Bun 1.4.3	Fast type checking only	No
typescript-go	Microsoft / TypeScript project	Foundation for TypeScript 7.x	Native-code compiler core used by both tsc and bun check	Yes, as part of tsc

Read that way, the story is less “Bun beats Microsoft” and more “Bun shipped a fast, narrow tool on top of Microsoft’s own native foundation before Microsoft finished shipping the full version of that foundation.” Both outcomes are good for developers tired of slow type checks, but the framing matters for understanding who actually controls the underlying technology.

From Zig to Rust: How Bun Got Here

Bun’s push toward bun check did not happen in isolation. Bun 1.3.14 was the last release written primarily in Zig, the systems language Bun was originally built on. Bun 1.4.0, released August 20, 2026, marked a turning point: it was the first release to ship Bun’s JavaScript, TypeScript, and CSS transpiler, minifier, and bundler work rewritten in Rust. Bun 1.4.1 followed on September 4, 2026, continuing that transition, before 1.4.3 arrived on October 10 with bun check as the most visible result of that groundwork.

The Rust Rewrite Began in August

That sequencing matters for understanding why bun check arrived when it did rather than earlier. Bun’s team spent the back half of 2026 rebuilding core pieces of its toolchain in Rust before layering a TypeScript-specific checker on top of a ported version of Microsoft’s own native compiler core. It is a case of two separate performance bets, Bun’s internal Rust rewrite and Microsoft’s native TypeScript-go rewrite, intersecting in a single release.

Bun’s Broader Speed Claims Against npm and pnpm

bun check is the headline of 1.4.3, but it sits inside a larger pattern of install and runtime speed claims Bun has published across its benchmark suite, run on the same AMD EPYC 9R14 hardware used for the type-checking tests. Those numbers, while not new to this release, are part of why some teams were already primed to try Bun’s checker rather than sticking with their existing setup.

Scenario	Bun install RAM use	pnpm RAM use	Reported speed gap
Benchmark case 1	376 MB	1.8 GB	10x to 15x faster
Benchmark case 2	52 MB	1.1 GB	7x to 30x faster
Benchmark case 3	214 MB	2.7 GB	5x to 19x faster
Benchmark case 4	12 MB	1.4 GB	8x to 21x faster

Bun also publishes comparisons for serving Express over HTTPS and querying PostgreSQL 18.3 through Bun.sql against postgres.js 3.4.9, along with a WebSocket broadcast test against the ws library running on Node.js. All of these benchmarks share the same methodology note: medians of three runs, with full methodology published in each benchmark’s own documentation, an approach that at least gives outside reviewers a way to attempt their own reproduction.

Why Build Tool Speed Has Become a Competitive Battlefield

Developer tooling has quietly become one of the most competitive corners of software in 2026, and type checking speed is a proxy for a bigger fight over where engineering time actually goes. Every minute spent waiting on a type check or a build is a minute an engineer is not writing code, and at scale that adds up to real payroll cost. That same logic is why coverage of .NET 11 RC2’s race against Java 27 and the ongoing contest among Zed, VS Code, and JetBrains Air keeps circling back to raw speed as a selling point, not just feature lists.

There is also a defensive angle for Bun here. As AI coding agents generate more code and run more automated checks per commit, the cost of a slow type checker multiplies across every agent loop. A recent industry study covered by TrendinTech found that AI coding agents can actually slow experienced developers down by roughly 19% in some workflows, a finding that puts extra pressure on every other part of the toolchain, including type checking, to claw back time wherever it can.

What Engineers Are Saying

Beyond Bun’s own claims and Scrydon’s measured adoption, the broader reaction has focused on the gap between a clean benchmark and a messy production codebase. Writing shortly after the release, independent developer Azeem Hassni documented the feature’s behavior against a working project, noting in a post published October 11 that results can vary depending on whether a project pins a stable TypeScript release or tracks a development build, since bun check is built against the TypeScript 7 line rather than older TypeScript versions some teams still run.

That kind of edge case is normal for any tool built on a moving target, and it is also why Bun’s own documentation frames bun check as reporting “the same errors as tsc” rather than promising identical behavior in every situation. Teams running older TypeScript configurations, or relying on compiler APIs still being finalized for TypeScript 7.1, are the ones most likely to hit friction first.

The Caveats Nobody Should Skip

Three caveats are worth repeating before any team rewrites its CI pipeline around bun check. First, every headline performance number in this story, the 3x to 6.4x range, the 89% idle CPU reduction, the 2.2x memory savings, comes from Bun’s own benchmark publication rather than an independent lab. Second, bun check does not emit compiled output, so it cannot fully replace tsc in any pipeline that needs built JavaScript or declaration files, only in the type-checking step itself. Third, TypeScript 7.1 is still a beta as of October 21, 2026, with Microsoft describing a release candidate roughly a month away rather than a finished product, so direct comparisons between Bun’s checker and TypeScript’s newest compiler line are necessarily comparisons against a moving target.

What Comes Next for Bun and TypeScript Tooling

A few trends look likely to play out over the coming months based on the pattern established by this release cycle.

More teams will adopt bun check as a pre-commit or CI gate specifically for type checking, while keeping tsc or another compiler step for the final build, mirroring Scrydon’s hybrid approach.
Microsoft’s TypeScript 7.1 stable release, once it ships following its beta and expected release candidate, will likely narrow the gap with Bun’s benchmark numbers, since both tools share the same native typescript-go foundation.
Expect more independent benchmark attempts to replicate Bun’s 3x to 6.4x claims across different codebases and hardware, which will either confirm or soften the headline figures as more real-world data accumulates.
Other JavaScript tooling projects will face pressure to add similarly fast, narrowly scoped checking tools rather than relying solely on wrapping the standard TypeScript compiler.
Expect continued emphasis on idle-resource efficiency, not just peak throughput, as cloud cost scrutiny keeps rising alongside AI-driven compute demand.

None of those predictions require Bun and TypeScript to be enemies. If anything, Bun’s move validates the underlying bet Microsoft made years ago when it began the native rewrite that became typescript-go. The real competition is not Bun against Microsoft so much as both projects racing to turn that one foundation into the fastest possible developer experience first.

Frequently Asked Questions

What is bun check in Bun 1.4.3?
It is a built-in TypeScript type checker shipped in Bun 1.4.3, released October 10, 2026. It reads an existing tsconfig.json file, reports type errors, and runs across every available CPU core.

Is bun check actually faster than tsc?
Bun’s own benchmarks claim a range of 3x to 6.4x faster on a 16-core Apple silicon Mac, with specific project tests showing results like 0.27 seconds versus 0.80 seconds on a Nuxt project. Independent testing from Scrydon’s engineering team found real-world gains of roughly 1.8x to 2.4x on a cold check of its full repository, somewhat more modest than Bun’s best-case figures but still substantial.

Does bun check replace the TypeScript compiler entirely?
No. It performs type checking only and does not emit JavaScript or .d.ts declaration files. Projects that need compiled output still need tsc or another build step alongside it.

When did Bun 1.4.3 ship, and who built it?
Bun 1.4.3 shipped October 10, 2026. The release announcement was authored by Jarred Sumner, who created Bun.

What is TypeScript 7.1 Beta and how does it relate to Bun?
TypeScript 7.1 Beta was announced by Microsoft on October 20, 2026, ten days after Bun 1.4.3. It adds stable es2026 support for the target and lib settings. Bun’s bun check benchmarks compare against TypeScript 7.0.2, the stable release that preceded this beta, since both tools are built on the same native typescript-go foundation.

What language is Bun written in now?
Bun 1.3.14 was the last release written primarily in Zig. Bun 1.4.0, released August 20, 2026, became the first release with its transpiler, minifier, and bundler work rewritten in Rust, with that transition continuing through 1.4.1 and into 1.4.3.

Should teams switch their CI pipeline to bun check today?
Based on early adopter reports like Scrydon’s, a common approach is to use bun check as a fast type-checking gate in CI or pre-commit hooks while keeping tsc or another build tool for generating compiled output and declaration files, rather than removing tsc entirely.

What is typescript-go and why does it matter for bun check?
typescript-go is Microsoft’s native-code rewrite of the TypeScript compiler, the foundation underlying TypeScript 7.x. Bun’s check command is built on a port of that same foundation, meaning both Microsoft’s tsc and Bun’s checker rely at their core on the same type-checking engine, parallelized differently by each tool.

Bun 1.4.3’s bun check Beats tsc by 6.4x [2026]