Key details

  1. Bun 1.4 was released August 20, 2026.
  2. It is the first stable Bun release based on the project's rewrite from Zig to Rust.
  3. Bun says 1.4 adds 1,517 passing tests from Node.js's own suite and fixes more than 2,900 issues.
  4. The runtime now targets Node.js 26.3.0 and reports `NODE_MODULE_VERSION` 147; native addons built for Node 24 must be rebuilt.
  5. New built-ins include `Bun.WebView`, `Bun.Image`, `Bun.markdown`, `Bun.cron`, `Bun.Terminal`, JSON5 and XML support.
  6. Bun reports up to 35% lower memory use overall, five-times lower idle CPU use and roughly 2x faster startup on Linux in its own benchmarks; these are vendor-produced measurements.
  7. The project maintains explicit 1.4 breaking-change and Rust-port regression trackers rather than presenting the rewrite as compatibility-risk-free.

What builders should take away

  1. Treat Bun 1.4 as a runtime migration, not a routine version bump. Run framework tests, long-lived server workloads, package installs, builds and deployment images against the exact 1.4 binary before changing a fleet-wide default.
  2. Rebuild and test native addons if your workload previously targeted Node 24 compatibility; the Node ABI reported by Bun has moved with its Node 26.3 target.
  3. Inventory dependencies that overlap new built-ins such as browser automation, image processing, Markdown, cron and terminal handling. Remove a dependency only when the Bun API covers your required behavior and portability targets, not simply because a built-in now exists.
  4. Benchmark memory, startup and CPU on representative production workloads. Bun's published improvements are promising but come from the vendor and vary by framework and host environment.
  5. Keep a rollback path during the first 1.4 rollout and monitor the breaking-change and regression trackers for issues that match your OS, architecture, package manager or framework stack.

What changed

Bun released version 1.4 on August 20 after moving the runtime and tooling implementation from Zig to Rust. The release adds 1,517 passing tests from Node.js's own test suite, targets Node.js 26.3 compatibility, fixes more than 2,900 issues according to the project, and expands the single binary with APIs that replace common dependencies including browser automation, image processing, Markdown, cron and terminal handling. Bun also reports materially lower startup time, memory and idle CPU use across its own test workloads. The migration is not compatibility-neutral: Bun now reports Node.js 26.3.0 and `NODE_MODULE_VERSION` 147, so native addons built for Node 24 must be rebuilt, and the project maintains an explicit 1.4 breaking-change tracker and upgrade guidance.

Why it matters

Bun's pitch has always been an integrated JavaScript toolchain, but 1.4 changes both the implementation foundation and how much application infrastructure can move into the runtime binary itself. Teams can potentially remove dependencies such as Puppeteer-style browser control, sharp-style image processing, cron helpers and terminal libraries from some workloads, while the Node-compatibility jump reduces another class of migration blockers. At the same time, a full implementation rewrite creates regression risk that ordinary semver expectations do not capture. Builders should therefore treat 1.4 as a runtime migration: test native modules, framework workloads, long-lived servers and build pipelines before broad rollout, and regard Bun's performance numbers as vendor benchmarks until they are reproduced independently.

The implementation moved from Zig to Rust

Bun 1.4 is the first stable release of the project's Rust port. That makes the release architecturally different from an ordinary feature train: the implementation language underneath the runtime, package manager, bundler and tooling has changed while Bun aims to preserve its external behavior. The project tracked regressions through the canary cycle, with most listed Rust-port issues closed before release but at least some platform-specific work still open.

Node compatibility took its biggest jump since 1.0

Bun says 1.4 adds 1,517 passing tests from Node.js's own test suite, its largest compatibility increase since Bun 1.0. The compatibility target is now Node.js 26.3.0. This matters for packages that gate behavior on Node versions, but it also changes the native-module ABI: `NODE_MODULE_VERSION` is 147, and addons compiled for Node 24 need to be rebuilt.

The binary absorbs more dependencies

The release expands Bun's built-in APIs with `Bun.WebView`, `Bun.Image`, `Bun.markdown`, `Bun.cron`, `Bun.Terminal`, JSON5, XML and archive helpers, plus parallel run/test commands. The practical value is not merely fewer installs: some applications can remove native or browser-automation dependencies and their update/build surface. `Bun.WebView`, for example, can drive system WebKit on macOS or an installed Chromium-family browser through CDP, while `Bun.Image` covers common image transformations without a separate native addon.

Performance claims are large but vendor-produced

Bun reports lower memory use across several server workloads, faster startup on Windows and Linux, five-times lower idle CPU use and smaller binaries on Linux and Windows. Its published table shows reductions such as Fastify memory falling from 233 MB to 120 MB and Next.js from 397 MB to 285 MB in the project's test setup. Those are useful signals, not neutral benchmarks: teams should reproduce them on their own traffic, frameworks, filesystems and host hardware before turning them into capacity assumptions.

The upgrade has real compatibility edges

Bun maintains a dedicated 1.4 breaking-change tracker. Beyond the Node ABI bump, x64 distribution changes remove the separate Haswell-targeted build in favor of baseline artifacts with runtime SIMD dispatch, and the upgrade work documents behavior changes accumulated during the Rust port. The project's regression tracker is also a reminder that a rewrite can surface workload-specific problems even after broad canary testing.

What to watch next

  • Independent benchmarks that reproduce or qualify Bun's 1.4 memory, startup and CPU claims across production-style JavaScript workloads.
  • Post-release regression reports attributable to the Rust rewrite, especially on less common operating systems and native-module stacks.
  • How quickly Node.js ecosystem packages stop requiring Bun-specific compatibility work as the Node test-suite pass rate rises.
  • Whether developers replace established dependencies with Bun's new built-ins or continue preferring portable npm packages across Node, Deno and Bun.

Still unclear

  • Bun's performance figures are first-party measurements and may not generalize to different hardware, application shapes or deployment environments.
  • A broad rewrite can expose regressions after stable release even when the public canary tracker shows many issues resolved.
  • The long-term maintenance and portability trade-off of adopting Bun-specific built-ins depends on whether teams need to run the same application under other JavaScript runtimes.

Sources

Direct reading behind this dossier.

3 sources
Bun 1.4
Bun primary

Primary release announcement for the Rust rewrite, Node compatibility work, new built-ins and vendor performance measurements.

List of breaking changes for 1.4 (#28792)
oven-sh/bun / GitHub primary

Project-maintained breaking-change tracker, refreshed shortly before release; documents the Node 26.3 target, native addon ABI impact and x64 artifact changes.

Rust port regressions (#31477)
oven-sh/bun / GitHub primary

Project regression tracker for the Rust port, useful for qualifying the migration risk and showing issues found during canary testing.