# oven-sh/bun for Claude Code: what it does and how to install it

> The oven-sh/bun plugin packages 6 Claude Code commands and 8 skills taken from Bun's own repository, for people changing Bun's runtime itself: upgrading its BoringSSL and WebKit forks, writing native JavaScriptCore bindings in C++ or Rust, chasing garbage collector bugs, and writing bundler and dev server tests. It does not help with using Bun in a project.

Canonical: https://www.flowy.sh/plugins/oven-sh-bun/guide
Published: 2026-10-29
Updated: 2026-10-29
Author: Flowy

## What is oven-sh/bun?

`oven-sh/bun` is the source repository for Bun, which describes itself as an
incredibly fast JavaScript runtime, bundler, test runner, and package manager
in one tool, with 95,761 GitHub stars behind it. Inside that same repository
sits a small Claude Code plugin: 6 commands and 8 skills that Bun's own
contributors use while working on the runtime itself, not tools for running
Bun in your own project.

This is not a plugin for building or running a JavaScript or TypeScript app,
installing packages, or bundling code with Bun. It is procedural knowledge
for people changing Bun's own C++ and Rust internals, keeping its vendored
forks current, or writing its own test suite, so if you are not editing
Bun's source tree, none of the 14 components here apply to you.

## What do the six commands do?

Three of them are GitHub triage for Bun's own repository. `find-duplicate-prs`
looks for open pull requests that may duplicate a given PR. `find-issues`
looks for GitHub issues that a PR might fix. `dedupe` looks for duplicate
GitHub issues. All three read Bun's issue and PR queue rather than touch
code, the kind of thing a maintainer runs before reviewing or closing
something.

The other three keep Bun's vendored, forked dependencies current by hand.
`upgrade-boringssl` brings Bun's BoringSSL fork up to the latest upstream
Google BoringSSL. `upgrade-webkit` brings Bun's WebKit fork up to the latest
upstream WebKit. `upgrade-nodejs` walks through raising the Node.js version
that Bun reports, for compatibility with Node packages and native addons.
Bun forks and pins these projects instead of pulling them in as ordinary
dependencies, so someone has to do this work by hand on a schedule, and
these three commands are that work.

## What do the eight skills cover?

Four of them are about wiring new behavior into Bun's engine.
`implementing-jsc-classes-cpp` is for implementing JavaScript classes in C++
using JavaScriptCore, with C++ bindings, prototypes, or constructors.
`implementing-jsc-classes-rust` does the same job through Bun's own Rust
bindings generator, for new JS APIs written in Rust with JavaScriptCore
integration. `javascriptcore-garbage-collector` is a reference for Bun's
garbage collector work: use-after-free bugs, JS object leaks, objects that
get collected too early, and the write barrier and root-tracking calls that
come up while debugging them. `rust-system-calls` guides file operations and
file descriptor handling in Rust through Bun's own system call helper,
instead of reaching for the Rust standard library or libc directly.

The remaining four cover testing and verification.
`writing-dev-server-tests` guides writing hot module reloading and dev
server tests in Bun's own dev server test directory. `writing-bundler-tests`
guides writing bundler tests with Bun's own bundler test helpers, for
changes to the bundler, transpiler, or code transformation. `verify` drives
Bun's debug binary end to end to check that a runtime change actually works.
`slowest-tests` pulls the slowest test files from a recent CI run and can
post the results to a chat channel as a table, for anyone asking what is
making CI slow.

## Who should use oven-sh/bun?

Every one of these 14 components is scoped to Bun's own codebase in its own
description. They pay off if you have Bun's source checked out and you are
upgrading a forked dependency, adding a native binding, chasing a garbage
collector bug, or writing a bundler or dev server test. If you are only
using Bun to run a script, install packages, or bundle your own app, this
plugin has nothing for you: none of its parts touch your project's code,
they touch Bun's own C++, Rust, and test suite. Flowy indexes it as
contributor tooling for the Bun project, separate from Bun the runtime you
would otherwise reach for on the command line.

## How do I install oven-sh/bun in Claude Code?

Flowy indexes `oven-sh/bun` from its public GitHub repository. Install it
from [the install card on the listing page](https://www.flowy.sh/listings/oven-sh-bun#install), and the 6 commands
and 8 skills described above become available in that session.

Sources: [oven-sh/bun on GitHub](https://github.com/oven-sh/bun), [oven-sh/bun README](https://github.com/oven-sh/bun#readme)

## Common questions

### What does the oven-sh/bun Claude Code plugin do?

It packages 6 commands and 8 skills taken from Bun's own repository for people working on Bun's runtime itself. The commands cover GitHub issue and PR triage plus upgrading Bun's vendored BoringSSL and WebKit forks and its reported Node.js version. The skills cover native JavaScriptCore bindings in C++ and Rust, a garbage collector reference, a Rust system calls guide, and writing or running Bun's own tests.

### Is this plugin useful if I just want to use Bun in my own project?

No. None of its 14 components touch your project's code, they are written for someone changing Bun's own C++ and Rust internals, tests, or vendored dependencies. Running scripts, installing packages, or bundling your own app with Bun does not need this plugin at all.

### What is the difference between implementing-jsc-classes-cpp and implementing-jsc-classes-rust?

implementing-jsc-classes-cpp is for implementing a new JavaScript class in C++ using JavaScriptCore, with C++ bindings, prototypes, or constructors. implementing-jsc-classes-rust does the same job through Bun's own Rust bindings generator, for a new JS API written in Rust with JavaScriptCore integration.

### What does the javascriptcore-garbage-collector skill help debug?

It is a JavaScriptCore garbage collector reference written for Bun's own codebase. It covers use-after-free bugs, JS object leaks, objects that get collected too early, and the collector's write barrier and root-tracking calls, such as WriteBarrier, visitChildren, and JSC::Strong or Weak references.

### How many components does Flowy index for oven-sh/bun, and what kind are they?

Flowy indexes 14 components for oven-sh/bun: 6 commands and 8 skills, with no agents, MCP servers, or hooks in this listing. The commands handle GitHub triage and dependency upgrades, and the skills cover native bindings, garbage collector debugging, and Bun's own test suites.

## Related

- [The listing page](https://www.flowy.sh/listings/oven-sh-bun): Install command, components and repository
- [Alternatives to this plugin](https://www.flowy.sh/alternatives/oven-sh-bun): Peers in its category, ranked by stars
- [The Claude Code plugin marketplace](https://www.flowy.sh/marketplace/plugins): How plugins install, and every plugin in the index
- [superpowers for Claude Code: what it does and how to install it](https://www.flowy.sh/plugins/superpowers-flow/guide): another plugin guide
- [mattpocock/skills for Claude Code: install and use](https://www.flowy.sh/plugins/matt-pocock-flow/guide): another plugin guide