Jarred Sumner

Jarred Sumner created Bun, the open-source JavaScript and TypeScript toolkit that combines a runtime, bundler, package manager, and test runner. What began as an attempt to shorten a 45-second development cycle became infrastructure for distributing coding agents. Jarred and the Bun team joined Anthropic in December 2025; his subsequent work includes directing an AI-assisted Rust rewrite designed to address recurring memory-management defects while preserving Bun’s behavior.

A slow game-development loop becomes Bun

In 2021, Jarred was building a browser-based voxel game. Testing a change took about 45 seconds, mostly waiting for the Next.js development server to reload. He began porting esbuild’s JSX and TypeScript transpiler from Go to Zig. Supporting server-side rendering then required a JavaScript runtime. After studying WebKit’s source, he embedded JavaScriptCore, the engine used by Safari.

Jarred wrote the initial implementation over roughly a year. Zig’s low-level control and attention to performance attracted him, and he later credited the language with making Bun’s ambitious scope possible. The project grew to cover compilation, package installation, testing, and Node.js APIs rather than accelerating only the original game’s build process.

Bun’s July 2022 public release brought a different job: answering users, raising a $7 million seed round, and recruiting engineers. Bun 1.0 followed in September 2023, alongside growing production use. The team subsequently added Windows support, improved Node.js compatibility, and expanded the toolkit with database clients and a frontend development server. Compatibility remained central to the ambition: Bun was intended to replace Node.js in existing applications, which required implementing the behavior those applications already depended on.

Distribution changes the business direction

Bun’s single-file executables became especially useful for AI coding tools. A JavaScript project could be compiled into a self-contained binary that ran without a separate Bun or Node.js installation, with support for native addons and fast startup. Claude Code, FactoryAI, and OpenCode used Bun to distribute their tools.

The relationship with Anthropic developed before the acquisition. The Bun team had been prioritizing Claude Code issues for months, and their collaboration helped deliver Claude Code’s native installer. Jarred also became an intensive Claude Code user. In his December 2025 account, he described a bot working from the team’s internal Discord to propose bug fixes, respond to review comments, and submit tests that failed against an earlier Bun version and passed against the fixed debug build.

Joining Anthropic changed Bun’s anticipated business model. The team had expected eventually to build a hosting product integrated with its runtime and bundler. Jarred wrote that Bun still had more than four years of runway and no revenue when it joined Anthropic: he chose the acquisition over pursuing that monetization plan. Anthropic already depended on Bun, giving it a direct reason to fund the tooling. Both companies committed to keeping Bun open source and MIT-licensed, developed publicly by the same team.

Jarred’s argument for the move also concerned the code agents would produce. If software was written and tested in greater volume, with people inspecting fewer individual lines, he expected the runtime’s speed and predictability to become more consequential.

Reconsidering Zig without abandoning its contribution

Jarred’s July 2026 account of rewriting Bun in Rust explains a change in his own technical position. Zig had enabled the original project, but combining manually managed native memory with JavaScript’s garbage collector repeatedly produced leaks and crashes. Cleanup could be missed on an error path, run twice, or happen while an asynchronous operation still held a pointer.

The team already ran AddressSanitizer checks on every commit, fuzzed runtime APIs, and maintained memory-leak tests. Jarred wanted to prevent more errors before code ran. Rust’s ownership checks and automatic cleanup through Drop offered a way to move some of that responsibility into the language. He considered C++ and stricter ownership conventions in Zig, but those approaches would still depend heavily on review and consistent adherence to rules.

A conventional rewrite appeared prohibitively expensive. Jarred estimated that it would occupy several engineers for a year, delaying fixes and features. Testing a pre-release Claude model changed his assessment: as substantial parts of the existing test suite began passing, he moved from experimenting to intending to merge the port.

Preserving behavior while changing the implementation

Jarred organized the rewrite around three decisions:

• Translate before redesigning. The initial goal was a close mechanical port that preserved Bun’s architecture and behavior. More idiomatic Rust and reductions in unsafe code could follow. The existing TypeScript test suite supplied checks independent of the implementation language.
• Separate implementation from adversarial review. Reviewers in separate model contexts searched for defects without inheriting the implementer’s reasoning. One caught a boxed pipe being freed before an asynchronous close callback finished using it—a plausible-looking translation that compiled but introduced use-after-free and double-free errors.
• Repair the workflow when failures repeated. Jarred monitored the generated work and changed instructions when agents interfered with one another’s Git operations or replaced difficult implementations with stubs. He also manually compared code and checked that passing tests were actually running.

The port reached passing tests across supported platforms in 11 days. Jarred distinguished confidence sufficient to merge from confidence sufficient to release. He subsequently documented 19 known regressions, all fixed by the time of his account. One came from placing a required side effect inside Rust’s debug_assert!: release builds removed the expression, breaking part of hot reloading even though debug builds worked.

The rewrite’s benefits were similarly concrete. In the team’s repeated-build comparison, Bun 1.3.14’s memory use continued growing, reaching roughly 6.7 GB after 2,000 builds; the Rust-based 1.4.0 comparison leveled off around 609 MB. Jarred attributed the improvement to cleanup changes and expanded leak detection. His case for the rewrite rests on those observable failures and improvements, alongside compiler checks, testing, fuzzing, and human inspection—not on generated code compiling successfully alone.