In July 2022, a self-taught developer named Jarred Sumner released a project that made the JavaScript community do a collective double-take. Bun was not merely another runtime — it was an all-in-one toolkit that combined a JavaScript and TypeScript runtime, a package manager, a bundler, a transpiler, and a test runner into a single executable. Built from scratch in Zig and powered by Apple’s JavaScriptCore engine instead of Google’s V8, Bun posted benchmark numbers that seemed almost impossible: startup times measured in microseconds rather than milliseconds, package installations that completed seven times faster than npm, and an HTTP server that handled three times more requests per second than Node.js running Express. Within a week, the project had accumulated over 20,000 GitHub stars. Within three years, it had surpassed 85,000 stars, secured $7 million in seed funding from Kleiner Perkins, shipped a stable 1.0 release, and been acquired by Anthropic to power their AI coding infrastructure. This is the story of how one engineer’s obsession with performance created a serious challenger to the JavaScript runtime that had dominated server-side development for over a decade.
Early Life and Path to Technology
Jarred Sumner grew up in the San Francisco Bay Area, where immersion in the tech-saturated culture of Northern California sparked an early fascination with computers and programming. He was not a product of the traditional computer science pipeline — Sumner was self-taught, learning to code as a teenager and building projects that demonstrated both ambition and practical instinct. By around 2012, while still in his teens, he was already exploring Ruby on Rails and web development, driven by the same curiosity that would later lead him to question every assumption about how JavaScript runtimes should work.
Sumner’s first significant professional experience came at Lockitron, a smart lock startup, where he joined as the first employee at age 16. There he worked on e-commerce systems and user onboarding flows — the kind of work that forces a young developer to think about performance, user experience, and the entire stack from frontend to backend. This early exposure to startup engineering, where every millisecond of page load time and every friction point in the user journey matters, planted seeds that would germinate years later in Bun’s design philosophy.
After Lockitron, Sumner joined Stripe as a frontend engineer. Stripe’s engineering culture is legendary in Silicon Valley — the company is known for hiring developers who think deeply about developer experience, API design, and the invisible infrastructure that makes complex systems feel simple. Working at Stripe gave Sumner a front-row seat to one of the best engineering organizations in the world, and it reinforced a conviction that would drive all his subsequent work: the tools that developers use every day should be fast, elegant, and free of unnecessary friction. The frustrations he experienced with the JavaScript toolchain at Stripe — the slow startup times of Node.js, the fragmented ecosystem of bundlers and transpilers, the sluggish package installations — were not abstract complaints. They were daily productivity drains that he believed could be solved with better engineering at the runtime level.
The Breakthrough: Creating Bun
Sumner began working on Bun in 2021, initially as a solo project. The premise was radical in its ambition: rather than building yet another tool that solved one piece of the JavaScript puzzle, he would build an entire toolkit from scratch — runtime, package manager, bundler, transpiler, and test runner — unified in a single binary. The first public preview appeared in mid-2021, and the initial public release (v0.1.0) came in July 2022. The reaction was immediate and electric.
Technical Innovation
To understand why Bun matters, you need to understand the state of server-side JavaScript before it arrived. Since Ryan Dahl created Node.js in 2009, the platform had grown into the dominant server-side JavaScript runtime, powering everything from startup MVPs to Netflix’s streaming infrastructure. But Node.js carried the weight of design decisions made over a decade earlier, and its ecosystem had fragmented into a sprawling landscape of specialized tools. Running a modern JavaScript project in 2022 typically required Node.js for the runtime, npm or Yarn or pnpm for package management, webpack or Rollup or esbuild for bundling, Babel or SWC for transpilation, and Jest or Vitest for testing. Each tool had its own configuration, its own dependencies, and its own startup overhead. The cognitive and computational cost of this fragmentation was enormous.
Bun’s first unconventional decision was its choice of JavaScript engine. While Node.js and Deno both use Google’s V8 engine, Sumner chose Apple’s JavaScriptCore (JSC) — the engine that powers Safari. JSC offered faster startup times and lower memory usage than V8, characteristics that aligned perfectly with Bun’s goal of making every interaction with JavaScript feel instantaneous. The trade-off was that V8 often outperforms JSC on sustained CPU-intensive computation, but Sumner bet that for the typical use cases of a server-side runtime — handling HTTP requests, reading files, managing processes — startup speed and memory efficiency mattered more than peak throughput on long-running calculations.
The second radical decision was the implementation language. Rather than writing Bun in C or C++ (the languages behind Node.js and V8), Sumner chose Zig, the systems programming language created by Andrew Kelley. Remarkably, Sumner had never written a line of Zig before starting Bun. He taught himself the language while building the runtime, crediting the helpful Zig Discord community as a key enabler. Zig’s characteristics — explicit memory management, no hidden allocations, no hidden control flow, and excellent interoperability with C libraries — made it ideal for building a runtime where every microsecond counts. Zig’s comptime (compile-time code execution) feature allowed Sumner to optimize hot paths in ways that would be impossible or impractical in C++.
The result was a runtime with performance characteristics that defied expectations. Here is an example of a basic HTTP server in Bun that demonstrates its built-in API:
// A high-performance HTTP server using Bun's native API
// No external dependencies — Bun.serve() is built into the runtime
const server = Bun.serve({
port: 3000,
// The fetch handler follows the Web Standard Request/Response API
async fetch(req: Request): Promise<Response> {
const url = new URL(req.url);
if (url.pathname === "/api/health") {
return Response.json({ status: "ok", runtime: "bun" });
}
if (url.pathname === "/api/users" && req.method === "POST") {
const body = await req.json();
// Bun includes a built-in SQLite client — no npm install needed
const db = new Bun.SQLiteDatabase("app.db");
const stmt = db.prepare(
"INSERT INTO users (name, email) VALUES ($name, $email)"
);
const result = stmt.run({ $name: body.name, $email: body.email });
return Response.json({ id: result.lastInsertRowid }, { status: 201 });
}
// Bun.file() returns a lazy reference — the file is only read on demand
// and served with the correct Content-Type header automatically
return new Response(Bun.file("./public/index.html"));
},
});
console.log(`Server running at http://localhost:${server.port}`);This code illustrates several of Bun’s design principles: the use of Web Standard APIs (Request, Response, URL) instead of Node.js-specific abstractions, built-in database support without external packages, lazy file handling for optimal memory usage, and a TypeScript-first approach that requires zero configuration. The equivalent functionality in Node.js would require installing Express or Fastify for the HTTP server, better-sqlite3 for the database, and configuring TypeScript compilation separately.
The package manager that ships inside Bun represented another performance breakthrough. While Isaac Schlueter’s npm had been the foundation of the JavaScript package ecosystem since 2010, its installation speed had become a notorious bottleneck in development workflows. Bun’s package manager implemented the same npm registry protocol but with a completely rewritten resolution and installation algorithm, written in native Zig code rather than JavaScript. The result: bun install runs up to seven times faster than npm and seventeen times faster than Yarn for cached installations. For developers who run package installations dozens of times per day — switching branches, setting up CI pipelines, onboarding new team members — this was not a marginal improvement but a qualitative change in workflow.
Why It Mattered
Bun mattered because it challenged the assumption that the JavaScript ecosystem’s fragmentation was inevitable. For years, the community had accepted that you needed separate tools for separate tasks — a runtime here, a bundler there, a test runner somewhere else. Bun demonstrated that a single, well-engineered binary could replace the entire toolchain, and do so faster than any of the individual tools it replaced. This was not just a convenience improvement; it was an architectural argument that the boundaries between these tools were artificial, and that eliminating them could produce compounding performance and usability gains.
The project also demonstrated that the performance ceiling of server-side JavaScript was far higher than most developers assumed. When Bun’s benchmarks showed an Express-style HTTP server handling 52,000 requests per second compared to Node.js’s 13,000, it forced a reevaluation of whether perceived JavaScript performance limitations were inherent to the language or artifacts of the runtime implementation. Much of the performance gap came not from JavaScript execution speed but from the overhead of runtime initialization, module resolution, and I/O handling — all areas where Zig’s low-level control gave Bun a decisive advantage.
The Bun Ecosystem: From 1.0 to Acquisition
After the explosive debut in July 2022, Sumner founded Oven, the company behind Bun’s continued development. On August 24, 2022, Oven announced $7 million in seed funding led by Kleiner Perkins, with notable angel investors including Guillermo Rauch of Vercel — a significant endorsement from one of the most influential figures in the JavaScript ecosystem. The funding allowed Sumner to hire a small team of engineers and accelerate development toward a stable release.
Bun 1.0 shipped on September 8, 2023, marking the project’s transition from experimental curiosity to production-ready platform. The 1.0 release delivered on the core promise: a drop-in Node.js replacement that could run existing Node.js applications and npm packages without modification. It included a Jest-compatible test runner with snapshot testing and code coverage, native support for TypeScript and JSX without configuration, and production-ready builds for macOS and Linux with an experimental Windows build.
Bun 1.1 (April 2024) brought native Windows support, a stable WebSocket client, and further improvements to Node.js compatibility. Bun 1.2 (January 2025) was the most ambitious update yet, introducing a built-in PostgreSQL client (Bun.sql) with automatically prepared statements and connection pooling, a native S3 object storage API (Bun.s3) that was five times faster than the AWS SDK, and compatibility with 90 percent of the Node.js test suite across core modules. By this point, Bun had established a clear pattern: each major release expanded the boundary of what a JavaScript runtime could include out of the box, steadily reducing the need for external dependencies.
In December 2025, Anthropic acquired Oven and the Bun project. The acquisition was driven by a concrete technical dependency: Claude Code, Anthropic’s AI coding tool that had reached $1 billion in run-rate revenue within six months of its general availability, shipped as a Bun executable distributed to millions of developers across macOS, Linux, and Windows. Bun’s fast startup times and single-binary distribution model made it the ideal foundation for an AI-powered development tool that needed to feel instantaneous. Crucially, Bun remained open source and MIT-licensed after the acquisition, with the same team continuing development. Sumner continued leading Bun’s evolution while also contributing to Anthropic’s developer tooling infrastructure.
Philosophy and Approach
Key Principles
Sumner’s engineering philosophy reveals itself through the consistent decisions embedded in Bun’s design. Each choice reflects a coherent worldview about what developer tools should be.
Performance is a feature, not an optimization. Bun does not treat speed as something you achieve by profiling and tuning after the fact. Speed is baked into the architecture from the first line of code — the choice of Zig over C++, JavaScriptCore over V8, native implementations over JavaScript shims. Sumner has argued that when tools are fast enough, they change how developers work: tests get run more often, packages get installed without hesitation, servers restart instantly during development. The ripple effects of eliminating latency are far larger than the raw benchmark numbers suggest.
Unification over fragmentation. The JavaScript ecosystem’s tooling had evolved through specialization — each problem spawned a dedicated tool, each tool spawned configuration files, and the aggregate complexity became a barrier to entry. Bun’s answer was integration: a single binary that handles runtime execution, package management, bundling, transpilation, and testing. This is not merely a convenience; it enables optimizations that are impossible when tools operate independently. Bun’s package manager, for instance, can leverage its knowledge of the runtime’s module resolution algorithm to install packages in a layout that eliminates resolution overhead — an optimization that an independent package manager could never make. The approach echoes the philosophy that Brendan Eich brought to JavaScript’s original design: making the common case simple and fast, even if it means rethinking established boundaries.
Web Standards over proprietary APIs. Where Node.js introduced its own APIs for HTTP handling, file operations, and module loading, Bun defaults to Web Standard APIs wherever possible. Bun’s HTTP server uses the Fetch API’s Request and Response objects. Its module system supports ES modules natively. Its cryptographic operations align with the Web Crypto API. This decision means that code written for Bun is more portable — it can often run in browsers, Cloudflare Workers, and Deno with minimal changes — and that developers learning Bun are simultaneously learning standards that apply across the entire web platform.
Zero configuration as a design constraint. Bun runs TypeScript and JSX files directly — no tsconfig.json required, no Babel configuration, no webpack setup. The test runner works without a jest.config.js. The bundler operates with sensible defaults. This is not laziness in design but a deliberate engineering challenge: making the defaults good enough that most projects never need to touch a configuration file. For teams working on complex web applications, this philosophy dramatically reduces onboarding time and eliminates an entire category of debugging — the kind where the bug is not in your code but in your configuration. Teams using project management tools like Taskee to coordinate their development workflows benefit from this reduced configuration overhead, as it means fewer setup tickets and faster sprint velocity.
Legacy and Impact
Jarred Sumner’s impact on the JavaScript ecosystem extends beyond Bun’s raw performance numbers. He fundamentally altered the competitive landscape of server-side JavaScript and challenged assumptions that had calcified over a decade of Node.js dominance.
The most immediate impact was competitive pressure on Node.js itself. After Bun’s release, the Node.js core team accelerated performance improvements, added native TypeScript support (an experimental feature in Node.js 22), and began exploring built-in test runner capabilities. Ryan Dahl’s Deno project also intensified its focus on Node.js compatibility and performance. The existence of a viable, faster alternative forced the entire ecosystem to raise its standards. This pattern — a challenger project pushing incumbents to improve — has repeated throughout the history of computing, from the way competitive pressure among code editors drove innovation in developer tooling, to how Zig’s success inspired improvements in C compiler toolchains.
Bun also validated Zig as a language for building production-grade systems software. Before Bun, Zig was primarily known within the systems programming community. Bun brought Zig to the attention of the broader JavaScript ecosystem — millions of developers who had never considered a language below the abstraction level of TypeScript. The fact that Bun’s most impressive performance characteristics derived directly from Zig’s design properties (explicit memory management, no hidden allocations, compile-time code execution) served as a compelling advertisement for Andrew Kelley’s language. After Bun’s success, other projects began evaluating Zig for performance-critical JavaScript tooling.
The all-in-one toolkit model that Bun pioneered influenced how developers think about JavaScript tooling architecture. While the ecosystem had been moving toward greater specialization — separate tools for every task, connected by configuration — Bun demonstrated that integration could produce both better performance and better developer experience. This shift is visible in the broader trend toward integrated development platforms: Vercel combining hosting, CI/CD, and edge computing; Astro combining static generation, server rendering, and island architecture; and Deno expanding from runtime to include a package registry and deployment platform. For agencies and development teams managing the complexity of modern JavaScript projects, platforms like Toimi provide the project management infrastructure that complements these increasingly integrated technical toolchains.
Perhaps most remarkably, Bun’s acquisition by Anthropic in December 2025 represented a new chapter in the relationship between open source JavaScript infrastructure and artificial intelligence. As AI-powered coding tools become central to software development workflows, the performance characteristics of the underlying runtime — startup time, memory efficiency, distribution simplicity — become critical infrastructure concerns. Bun’s architecture, optimized for exactly these characteristics, positioned it as the ideal foundation for the next generation of developer tools. The fact that Claude Code, one of the most widely adopted AI coding assistants, runs on Bun means that Sumner’s engineering decisions about Zig, JavaScriptCore, and unified tooling are now affecting the daily workflow of millions of developers, even those who have never typed bun into a terminal.
At roughly 30 years old, Sumner has already reshaped the JavaScript ecosystem’s performance expectations, demonstrated a new model for tooling integration, validated a novel systems programming language for mainstream infrastructure, and built technology that underpins one of the most important AI developer tools in the world. From self-taught teenager in the Bay Area to the engineer whose runtime powers the future of AI-assisted coding, Sumner’s trajectory is a testament to what happens when relentless performance obsession meets the right moment in a technology ecosystem’s evolution.
Key Facts
- Known for: Creating Bun — the all-in-one JavaScript and TypeScript runtime, package manager, bundler, transpiler, and test runner
- Key technologies: Bun is written in Zig and powered by Apple’s JavaScriptCore engine
- Career: First employee at Lockitron (age 16), frontend engineer at Stripe, founder and CEO of Oven, now at Anthropic
- Major milestones: Bun first preview (2021), Bun v0.1.0 public release (July 2022), Oven founded with $7M seed (August 2022), Bun 1.0 stable (September 2023), Bun 1.1 with Windows support (April 2024), Bun 1.2 with built-in Postgres and S3 (January 2025), acquired by Anthropic (December 2025)
- Impact: Over 85,000 GitHub stars; up to 7x faster package installs than npm; 3x more HTTP requests per second than Node.js with Express
- Recognition: Google Open Source Peer Bonus (2022)
- Education: Self-taught programmer
Frequently Asked Questions
Who is Jarred Sumner and what did he create?
Jarred Sumner is a self-taught software engineer who created Bun, an all-in-one JavaScript and TypeScript toolkit that combines a runtime, package manager, bundler, transpiler, and test runner in a single executable. Before creating Bun, Sumner worked as a frontend engineer at Stripe. He founded Oven, the company behind Bun, in 2022, raising $7 million in seed funding from Kleiner Perkins. In December 2025, Anthropic acquired Oven and the Bun project. Bun is built in the Zig programming language and uses Apple’s JavaScriptCore engine, achieving dramatically faster performance than Node.js across startup times, package installation, and HTTP server throughput.
Why is Bun faster than Node.js?
Bun’s performance advantage comes from two fundamental architectural decisions. First, it uses Apple’s JavaScriptCore engine instead of Google’s V8, which provides faster startup times and lower memory usage — critical characteristics for server-side applications and development tooling. Second, Bun is implemented in Zig rather than C++, giving its developers fine-grained control over memory management and eliminating hidden allocations that add overhead. These choices, combined with native implementations of commonly used functionality (HTTP serving, file operations, package resolution) written in optimized Zig code rather than JavaScript, produce compounding performance gains. In benchmarks, Bun starts up to four times faster than Node.js, installs packages up to seven times faster than npm, and handles three times more HTTP requests per second when running Express.
Can Bun replace Node.js in existing projects?
Bun is designed as a drop-in replacement for Node.js, and as of version 1.2, it passes 90 percent of the Node.js test suite across core modules including path, os, events, stream, and fs. Most existing Node.js applications and npm packages work in Bun without modification. However, some edge cases remain — particularly around native Node.js addons compiled with node-gyp and certain Node.js-specific APIs that do not have direct equivalents in Bun’s architecture. For new projects, Bun offers a fully compatible alternative with significant performance benefits. For existing production applications, testing with Bun is straightforward since it uses the same package.json and node_modules conventions, but teams should validate their specific dependency tree before switching runtimes in production.
What happened when Anthropic acquired Bun?
In December 2025, Anthropic acquired Oven, the company behind Bun, to secure the infrastructure powering Claude Code — Anthropic’s AI coding tool that had reached $1 billion in run-rate revenue. Claude Code ships as a Bun executable distributed to millions of developers, making Bun’s fast startup times and efficient single-binary distribution model critical infrastructure for Anthropic’s products. After the acquisition, Bun remained fully open source under the MIT license, with the same engineering team continuing development. Jarred Sumner continued leading Bun while also contributing to Anthropic’s broader developer tooling efforts. The acquisition represented a new model in which AI companies invest in open source runtime infrastructure to ensure the performance and reliability of their developer-facing products.
