{% /raw %} All input is dispatched as OS-level events β sites can't distinguish `view.click()` from a real mouse click (`isTrusted: true`). Selector-based methods auto-wait for actionability, Playwright-style: the element must be attached, visible, stable, and unobscured before the action fires. ```ts await using view = new Bun.WebView({ width: 800, height: 600 }); await view.navigate("https://bun.sh"); await view.click("a[href='/docs']"); // waits for actionability, native click await view.scroll(0, 400); // native wheel event, isTrusted: true await view.scrollTo("#install"); // scrolls every ancestor, waits for visible const title = await view.evaluate("document.title"); const png = await view.screenshot({ format: "jpeg", quality: 90 }); await Bun.write("page.jpg", png); ``` All methods work across both backends: | Method | Description | | ------------------------------------------ | -------------------------------------- | | `navigate(url)` | Navigate to a URL | | `evaluate(expr)` | Evaluate JavaScript in the page | | `screenshot({format, quality, encoding})` | Capture a PNG/JPEG/WebP screenshot | | `click(x, y)` / `click(selector)` | Click at coordinates or a CSS selector | | `type(text)` | Type text into the focused element | | `press(key, {modifiers})` | Press a key with optional modifiers | | `scroll(dx, dy)` / `scrollTo(selector)` | Scroll by delta or to an element | | `goBack()` / `goForward()` / `reload()` | Navigation controls | | `resize(w, h)` | Resize the viewport | | `cdp(method, params)` | Raw Chrome DevTools Protocol call | | `view.url` / `view.title` / `view.loading` | Page state properties | `Bun.WebView` extends `EventTarget` β on the Chrome backend, CDP events are dispatched as `MessageEvent`s with the params on `event.data`. Constructor options include `backend` (`"webkit"`, `"chrome"`, or `{ type: "chrome", path, argv }`), `console` to capture page logs, and `dataStore` for persistent profiles. One browser subprocess is shared per Bun process; additional `new Bun.WebView()` calls open tabs in the same instance. ## Render Markdown in the Terminal with `bun ./file.md` You can now render Markdown files directly in your terminal. When you run `bun ./file.md`, Bun reads the file, renders it as beautifully formatted ANSI output, and prints it to stdout with no JavaScript VM startup overhead. {% raw %}In the next version of Bun
— Jarred Sumner (@jarredsumner) March 18, 2026
`Bun.WebView` programmatically controls a headless web browser in Bun pic.twitter.com/Yp8UiNoeoy
{% /raw %} You can also use the new `Bun.markdown.ansi()` API programmatically: ```ts // Render markdown to an ANSI-colored string const out = Bun.markdown.ansi("# Hello\n\n**bold** and *italic*\n"); process.stdout.write(out); // Plain text mode β no escape codes const plain = Bun.markdown.ansi("# Hello", { colors: false }); // Enable clickable hyperlinks const linked = Bun.markdown.ansi("[docs](https://bun.sh)", { hyperlinks: true, }); // Custom line width for wrapping const wrapped = Bun.markdown.ansi(longText, { columns: 60 }); // Inline images via Kitty Graphics Protocol (Kitty, WezTerm, Ghostty) const withImg = Bun.markdown.ansi("", { kittyGraphics: true, }); ``` ## Async stack traces for native errors {% raw %}In the next version of Bun
— Bun (@bunjavascript) April 4, 2026
`bun ./hello.md` & `Bun.markdown.ansi(string)` pretty-prints markdown to terminal-friendly ansi text pic.twitter.com/yp7jYKZL8k
{% /raw %} ## In-process `Bun.cron()` scheduler `Bun.cron` now supports an in-process callback overload that runs a function on a cron schedule. This is ideal for long-running servers and containers where you want scheduled work that shares state with the rest of your application. {% raw %}In the next version of Bun
— Jarred Sumner (@jarredsumner) March 30, 2026
Async stacktraces are supported on native APIs like node:fs, Bun.write, node:http, node:dns & more.
This makes debugging easier pic.twitter.com/PHospWtxtg
{% /raw %} This complements the existing OS-level `Bun.cron(path, schedule, title)` which registers persistent crontab/launchd/Task Scheduler entries. The in-process variant is lighter, works identically across platforms, and lets your handler access database pools, caches, and module-level state directly. **Key behaviors:** - **No overlap** β the next fire is scheduled only after the handler (and any returned `Promise`) settles. Slow async work won't pile up concurrent runs. - **Scheduled in UTC** β `0 9 * * *` means 9:00 UTC, regardless of the system time zone. (The OS-level `Bun.cron(path, schedule, title)` variant uses system local time, since that's how crontab/launchd/Task Scheduler work.) - **Error handling matches `setTimeout`** β synchronous throws emit `uncaughtException`, rejected promises emit `unhandledRejection`. Without a listener the process exits with code 1; with one, the job reschedules itself. - **`--hot` safe** β all in-process cron jobs are cleared before the module graph re-evaluates, so editing the schedule, handler, or removing the call entirely all take effect on save without leaking timers. - **`Disposable`** β `using job = Bun.cron(...)` auto-stops at scope exit. - **`ref`/`unref`** β `.ref()` (default) keeps the process alive; `.unref()` lets it exit naturally. ```ts // Error handling example process.on("unhandledRejection", (err) => console.error("cron failed:", err)); Bun.cron("* * * * *", async () => { await mightThrow(); // logged, then retried next minute }); ``` Thanks to @alii for the contribution! ## UDP Socket: ICMP Error Handling and Truncation Detection Two improvements to `Bun.udpSocket()` that bring it closer to libuv/Node.js behavior: **ICMP errors no longer silently close the socket.** On Linux, sending a UDP packet to an unreachable port previously caused the socket to silently close, breaking all other sends on the same socket. Now, ICMP errors (port unreachable, host unreachable, TTL exceeded, etc.) are surfaced through the `error` handler, and the socket stays open: ```js const sock = await Bun.udpSocket({ socket: { error(err) { console.log(err.code); // 'ECONNREFUSED' }, }, }); sock.send("ping", 1, "127.0.0.1"); // dead port β error handler fires, socket stays open ``` **Truncated datagrams are now detectable.** When a received datagram is larger than the receive buffer, the kernel silently truncates it. The `data` callback now receives a fifth `flags` argument so you can tell truncated payloads from complete ones: ```ts const sock = await Bun.udpSocket({ socket: { data(socket, data, port, address, flags) { if (flags.truncated) { console.log("Datagram was truncated!"); } }, }, }); ``` ## Unix Domain Socket Lifecycle Now Matches Node.js Bun's unix domain socket behavior was inverted from Node.js/libuv in two important ways: | | Node.js / libuv | Bun (before) | | --------------------------- | --------------- | --------------------------------- | | Existing file at bind time | `EADDRINUSE` | Silently unlinks and binds anyway | | Socket file after `close()` | Removed | Left on disk | This meant Bun could silently steal a live socket from another process on `listen()`, and leaked `.sock` files on `stop()`/`close()`. Now Bun matches Node.js semantics: binding to an existing socket file correctly returns `EADDRINUSE`, and closing a listener automatically cleans up the socket file. This applies to `Bun.listen`, `Bun.serve`, and `net.Server` with unix sockets. ```js import { existsSync } from "node:fs"; const listener = Bun.listen({ unix: "/tmp/my.sock", socket: { data() {}, open() {} }, }); existsSync("/tmp/my.sock"); // true listener.stop(); existsSync("/tmp/my.sock"); // false β automatically cleaned up ``` ```js // Binding to an existing socket now correctly throws EADDRINUSE // instead of silently taking over the socket import { listen } from "bun"; const a = listen({ unix: "/tmp/my.sock", socket: { data() {}, open() {} } }); try { // Previously: silently unlinked and stole the socket // Now: throws EADDRINUSE, matching Node.js behavior const b = listen({ unix: "/tmp/my.sock", socket: { data() {}, open() {} } }); } catch (e) { console.log(e.code); // "EADDRINUSE" } finally { a.stop(); } ``` ## Upgraded JavaScriptCore Engine Bun's underlying JavaScript engine (WebKit's JavaScriptCore) has been upgraded with over 1,650 upstream commits, bringing significant performance improvements, new language features, and bug fixes. ### Explicit Resource Management (`using` and `await using`) The `using` and `await using` declarations from the [TC39 Explicit Resource Management proposal](https://github.com/tc39/proposal-explicit-resource-management) are now supported natively in JavaScriptCore: ```js function readFile(path) { using file = openFile(path); // file[Symbol.dispose]() called automatically at end of block return file.read(); } async function fetchData(url) { await using connection = await connect(url); // connection[Symbol.asyncDispose]() awaited at end of block return connection.getData(); } ``` ### JIT Compiler Improvements - **Quick tier-up** β Functions that are proven stable now tier up to optimized DFG/FTL compilation faster, improving steady-state performance. - **`Array.isArray` intrinsic** β `Array.isArray()` is now a JIT intrinsic, making it significantly faster in hot paths. - **Faster `String#includes`** β Uses an optimized single-character search fast path. - **Improved BigInt performance** β Smaller memory footprint and faster arithmetic operations. - **Better register allocation** β Rewritten greedy register allocator coalescing for improved generated code. - **Faster promise resolution** β Micro-optimized promise reaction triggering and microtask queue draining, with a new `PerformPromiseThen` DFG/FTL optimization node. ### WebAssembly Improvements - SIMD shuffle optimizations and additional ARM64/x64 SIMD instruction support. - Memory64 bounds checking fixes. - Improved BBQ and OMG compiler codegen (conditional selects, better write barriers, tail-call fixes). ### JavaScript Spec Conformance Fixes - `TypedArray#sort` when the comparator accesses `.buffer` - `Array#includes(undefined, fromIndex)` hole handling - `Array#flat` with depth 0 and derived array bailout - `Array.prototype.concat` now checks all indexed accessors - `Array.prototype.copyWithin` return value - `Set` methods properly throw on non-object iterator `next()` result - `RegExp#@@matchAll` lastIndex clamping - `String#replace` surrogate-advancement fix for non-unicode regexps - Named vs numbered backreference handling in RegExp - Private fields no longer have attributes set when sealing/freezing objects ### Memory Allocator (libpas) Improvements - Retag-on-scavenge for improved memory safety - Page-based zeroing threshold reduced from 64MB to 1MB for faster large allocations - Faster bitfit heap utilization Thanks to @sosukesuzuki for the contribution! ## Improved standalone executables on Linux Standalone executables created with `bun build --compile` on Linux now use a proper ELF section (`.bun`) to embed the module graph, matching the existing approach on macOS and Windows. Previously, the embedded data was read from `/proc/self/exe` at startup, which failed when the binary had execute-only permissions (`chmod 111`). With this change, the kernel maps the data via `PT_LOAD` during `execve` β meaning zero file I/O at startup and no read permission required on the binary. ```bash $ bun build --compile app.ts --outfile myapp $ chmod 111 myapp $ ./myapp # works now on Linux ``` Thanks to @dylan-conway for the contribution! ## `URLPattern` is up to 2.3x faster `URLPattern.test()` and `URLPattern.exec()` are now significantly faster. The internal regex matching now calls the compiled regex engine directly instead of allocating temporary JavaScript objects for each URL component, eliminating up to 24 GC allocations per call. | Benchmark | Before | After | Speedup | | ------------------------------- | ------- | ------- | --------- | | `test()` match - named groups | 1.05 Β΅s | 487 ns | **2.16x** | | `test()` no-match | 579 ns | 337 ns | **1.72x** | | `test()` match - simple | 971 ns | 426 ns | **2.28x** | | `test()` match - string pattern | 946 ns | 434 ns | **2.18x** | | `exec()` match - named groups | 1.97 Β΅s | 1.38 Β΅s | **1.43x** | | `exec()` no-match | 583 ns | 336 ns | **1.73x** | | `exec()` match - simple | 1.89 Β΅s | 1.30 Β΅s | **1.45x** | ```js const pattern = new URLPattern({ pathname: "/api/users/:id/posts/:postId" }); // 2.16x faster pattern.test("https://example.com/api/users/42/posts/123"); // 1.43x faster pattern.exec("https://example.com/api/users/42/posts/123"); ``` As a side effect, `URLPattern` internals no longer pollute `RegExp.lastMatch` / `RegExp.$N` β previously, calling `pattern.test(url)` would leak internal regex state into these legacy static properties. Thanks to @sosukesuzuki for the contribution! ## Faster `Bun.stripANSI` and `Bun.stringWidth` SIMD optimizations across `Bun.stripANSI`, `Bun.stringWidth`, and the shared ANSI parsing helpers used by `Bun.sliceAnsi`, `Bun.wrapAnsi`, and Node's `readline.getStringWidth`. **Key improvements:** - **4Γ-unrolled SIMD prologue** for escape character scanning β processes 64 bytes at a time instead of 16, reducing the cost of the NEONβGPR transfer that gates the loop branch. - **SIMD terminator scans** inside ANSI escape parsing β CSI and OSC payloads (like hyperlink URLs) are now skipped in bulk instead of byte-by-byte. - **Lazy flat buffer allocation** in `stripANSI` β replaces `StringBuilder` with a raw `VectorIn the next version of Bun
— alistair (@alistaiir) April 1, 2026
`Bun.cron()` accepts a callback for recurring in-process tasks pic.twitter.com/HQ3s3rxGEO
{% /raw %} ## Keep-Alive for HTTPS Proxy CONNECT Tunnels Bun now reuses CONNECT tunnels for HTTPS-through-proxy requests. Previously, every proxied HTTPS request performed a fresh CONNECT handshake and TLS negotiation. Now, the tunnel and inner TLS session are pooled and reused across sequential requests to the same target through the same proxy with the same credentials β matching the behavior of Node.js + undici. This dramatically reduces latency and connection overhead when making multiple HTTPS requests through a proxy: ```js // All three requests now reuse a single CONNECT tunnel // instead of establishing 3 separate tunnels + TLS handshakes for (let i = 0; i < 3; i++) { const res = await fetch("https://example.com/api", { proxy: "http://user:pass@proxy.example.com:8080", }); console.log(res.status); } ``` Tunnels are keyed by proxy host/port, proxy credentials, target host/port, and TLS configuration β so different targets or different credentials correctly use separate tunnels. This also fixes intermittent `Malformed_HTTP_Response` errors that some users encountered when using `fetch` with HTTPS proxies. Thanks to @cirospaciari for the contribution! ## `TCP_DEFER_ACCEPT` for `Bun.serve()` on Linux `Bun.serve()` now sets `TCP_DEFER_ACCEPT` on Linux (and `SO_ACCEPTFILTER "dataready"` on FreeBSD), the same optimization nginx uses to reduce latency for incoming HTTP connections. Previously, accepting a new connection required two event loop wake-ups β one for the accept and another to discover the socket was readable. With `TCP_DEFER_ACCEPT`, the kernel defers the accept until the client has actually sent data (the HTTP request or TLS ClientHello), collapsing the two wake-ups into one: **Before:** 1. epoll wake β accept new socket 2. Return to epoll 3. epoll wake β socket readable β `recv()` β process β respond **After:** 1. epoll wake β accept new socket (data already buffered) β `recv()` β process β respond This is especially impactful for short-lived connections (e.g. HTTP/1.1 with `Connection: close`). `Bun.listen()` and `net.createServer()` are unchanged, since they may serve protocols where the server sends first. No effect on macOS or Windows. ## Bugfixes ### Node.js compatibility improvements - Fixed: `process.env` being completely empty when the current working directory is inside a directory without read permission (e.g., `chmod 111`). Previously, OS-inherited environment variables passed via `execve` were lost because the env loader returned early on `EACCES` before reading process environment variables. (@alii) - Fixed: Memory leak where every `vm.Script`, `vm.SourceTextModule`, and `vm.compileFunction` call leaked the resulting object due to a reference cycle in the internal `NodeVMScriptFetcher` (@sosukesuzuki) - Fixed: `pipeline(Readable.fromWeb(res.body), createWriteStream(...))` permanently stalling (and eventually spinning at 100% CPU) when piping `fetch()` response bodies under concurrency, caused by a race between the HTTP thread's body callback and JS accessing `res.body` (@dylan-conway) - Fixed: `Readable.prototype.pipe` crashing the process when piping an object-mode `Readable` into a byte-mode `Transform`/`Writable`. The `ERR_INVALID_ARG_TYPE` error is now properly emitted on the destination stream's `error` event instead of being thrown as an uncatchable exception, matching Node.js behavior. - Fixed: `node:dns/promises.getDefaultResultOrder` being `undefined` and `dns.getDefaultResultOrder()` returning the function object instead of a string (`"ipv4first"` / `"ipv6first"` / `"verbatim"`). Also added the missing `getServers` export to `dns.promises`. This broke Vite 8 builds under Bun. (@dylan-conway) - Fixed: `fs.realpathSync("/")` throwing `ENOENT` when running Bun under FreeBSD's Linuxulator compatibility layer or in minimal containers without `/proc` mounted (@ant-kurt) - Fixed: `fs.statSync().ino` returning `INT64_MAX` (`9223372036854775807`) for files with inodes β₯ 2βΆΒ³, causing all files on NFS mounts with high 64-bit inodes to report the same inode number. `dev` and `rdev` were also affected. All stat fields now match Node.js behavior for both `Stats` (Number) and `BigIntStats` (BigInt) paths. (@dylan-conway) - Fixed: `process.stdout.end(callback)` firing the callback before all data was flushed, causing output truncation at power-of-2 boundaries (64KB, 128KB, etc.) when the callback called `process.exit(0)` - Fixed: `Error.captureStackTrace` now includes async stack frames (e.g. `at asyncIn the next version of Bun
— Jarred Sumner (@jarredsumner) April 3, 2026
Threadpool & JIT threads now respect cgroup CPU limits instead of physical cores. This improves resource utilization in Docker & k8shttps://t.co/HCPy7jRCyG