Pulumi Blog: Bun

Introducing Bun as a Runtime for Pulumi

Julien Poissonnier — Wed, 08 Apr 2026 00:00:00 +0000

Last year we added support for Bun as a package manager for Pulumi TypeScript projects. Today we’re taking the next step: Bun is now a fully supported runtime for Pulumi programs. Set runtime: bun in your Pulumi.yaml and Bun will execute your entire Pulumi program, with no Node.js required. Since Bun’s 1.0 release, this has been one of our most requested features.

Why Bun?

Bun is a JavaScript runtime designed as an all-in-one toolkit: runtime, package manager, bundler, and test runner. For Pulumi users, the most relevant advantages are:

Native TypeScript support: Bun runs TypeScript directly without requiring ts-node or a separate compile step.
Fast package management: Bun’s built-in package manager can install dependencies significantly faster than npm.
Node.js compatibility: Bun aims for 100% Node.js compatibility, so the npm packages you already use with Pulumi should work out of the box.

With runtime: bun, Pulumi uses Bun for both running your program and managing your packages, giving you a streamlined single-tool experience.

Getting started

To create a new Pulumi project with the Bun runtime, run:

pulumi new bun

This creates a TypeScript project configured to use Bun. The generated Pulumi.yaml looks like this:

name: my-bun-project
runtime: bun

From here, write your Pulumi program as usual. For example, to create a random password using the @pulumi/random package:

bun add @pulumi/random

import * as random from "@pulumi/random";

const password = new random.RandomPassword("password", {
 length: 20,
});

export const pw = password.result;

Then deploy with:

pulumi up

Prerequisites:

Bun 1.3 or later
Pulumi 3.227.0 or later

Converting existing Node.js projects

If you have an existing Pulumi TypeScript project running on Node.js, you can convert it to use the Bun runtime in a few steps.

1. Update `Pulumi.yaml`

Change the runtime field from nodejs to bun:

Before:

runtime:
 name: nodejs
 options:
 packagemanager: npm

After:

runtime: bun

When the runtime is set to bun, Bun is also used as the package manager — there’s no need to configure a separate packagemanager option.

2. Update `tsconfig.json`

Bun handles TypeScript differently from Node.js with ts-node. Update your tsconfig.json to use Bun’s recommended compiler options:

{
 "compilerOptions": {
 "lib": ["ESNext"],
 "target": "ESNext",
 "module": "Preserve",
 "moduleDetection": "force",
 "moduleResolution": "bundler",
 "allowJs": true,
 "allowImportingTsExtensions": true,
 "verbatimModuleSyntax": true,
 "strict": true,
 "skipLibCheck": true,
 "noFallthroughCasesInSwitch": true,
 "noUncheckedIndexedAccess": true,
 "noImplicitOverride": true
 }
}

Key differences from a typical Node.js tsconfig.json:

module: "Preserve" and moduleResolution: "bundler": Let Bun handle module resolution instead of compiling to CommonJS. The bundler resolution strategy allows extensionless imports while still respecting package.json exports, matching how Bun resolves modules in practice.
verbatimModuleSyntax: true: Enforces consistent use of ESM import/export syntax. TypeScript will flag any remaining CommonJS patterns like require() at compile time.

3. Switch to ESM

Bun makes it easy to go full ESM and it’s the recommended module format for Bun projects. Add "type": "module" to your package.json:

{
 "type": "module"
}

With ECMAScript module (ESM) syntax, one thing that gets easier is working with async code. In a CommonJS Pulumi program, if you need to await a data source or other async call before declaring resources, the program must be wrapped in an async entrypoint function. With ESM and Bun, top-level await just works, so you can skip the wrapper function entirely and await directly at the module level:

import * as aws from "@pulumi/aws";

const azs = await aws.getAvailabilityZones({ state: "available" });

const buckets = azs.names.map(az => new aws.s3.BucketV2(`my-bucket-${az}`));

export const bucketNames = buckets.map(b => b.id);

If your existing program does use an async entrypoint with export =, just replace it with the ESM-standard export default:

// CommonJS (Node.js default)
export = async () => {
 const bucket = new aws.s3.BucketV2("my-bucket");
 return { bucketName: bucket.id };
};

// ESM (used with Bun)
export default async () => {
 const bucket = new aws.s3.BucketV2("my-bucket");
 return { bucketName: bucket.id };
};

4. Update the Pulumi SDK

Make sure you’re running @pulumi/pulumi version 3.226.0 or later:

bun add @pulumi/pulumi@latest

5. Install dependencies and deploy

pulumi install
pulumi up

Bun as runtime vs. Bun as package manager

With this release, there are now two ways to use Bun with Pulumi:

Configuration	Bun’s role	Node.js required?
`runtime: bun`	Runs your program and manages packages	No
`runtime: { name: nodejs, options: { packagemanager: bun } }`	Manages packages only	Yes

Use runtime: bun for the full Bun experience. The package-manager-only mode is still available for projects that need Node.js-specific features like function serialization.

Known limitations

The following Pulumi features are not currently supported when using the Bun runtime:

Callback functions (magic lambdas) are not supported. APIs like aws.lambda.CallbackFunction and event handler shortcuts (e.g., bucket.onObjectCreated) use function serialization which requires Node.js v8 and inspector modules that are only partially supported in Bun.
Dynamic providers are not supported. Dynamic providers (pulumi.dynamic.Resource) similarly rely on function serialization.

If your project uses any of these features, continue using runtime: nodejs. You can still benefit from Bun’s fast package management by setting packagemanager: bun in your runtime options.

Start using Bun with Pulumi

Bun runtime support is available now in Pulumi 3.227.0. To get started:

Create a new project: pulumi new bun
Read the docs: TypeScript (Node.js) SDK
Report issues or share feedback on GitHub or in the Pulumi Community Slack

Thank you to everyone who upvoted, commented on, and contributed to the original feature request. Your feedback helped shape this feature, and we’d love to hear how it works for you.

Pulumi + Bun: Supercharge Your Infrastructure Dependencies

Piers Karsenbarg — Mon, 28 Jul 2025 09:50:26 +0100

Today, we are announcing a new addition that allows Pulumi users to use Bun as their package manager, offering an alternative to npm, Yarn, or pnpm. Bun, a recently released JavaScript runtime, bundler, transpiler, and package manager, provides a faster way to manage Pulumi project dependencies.

What is this Bun thing you’re talking about?

If you’ve spent time around the JavaScript ecosystem, then you’ve probably heard of Bun. If you haven’t, then be aware that it presents itself as a JavaScript toolkit, a direct drop-in replacement for NodeJS. However, the part that we like at Pulumi is its use as a package manager. According to the Bun install documentation, switching from npm install to bun install can make your installations up to 25 times faster.

Pulumi uses Bun solely as a package manager. You cannot use Bun to write Automation API-based applications, nor do we have a language plugin for Bun.
This requires Bun version 1.2 or greater due to the text-based lockfile introduced in this version.

Getting started with Bun and Pulumi

If you’re already using NodeJS with Pulumi, the easiest way to install Bun is to run the following:

npm install -g bun

The Bun installation documentation has more information on other methods available.

How to use in a new project

If you want to try this out on a new project, you can use

mkdir new-bun-project && cd new-bun-project
pulumi new typescript

You’ll get the usual prompts to set the project name, the description, and the stack name:

This command will walk you through creating a new Pulumi project.

Enter a value or leave blank to accept the (default), and press <ENTER>.
Press ^C at any time to quit.

Project name (new-bun-project):
Project description (A minimal TypeScript Pulumi program):
Created project 'new-bun-project'

Please enter your desired stack name.
To create a stack in an organization, use the format <org-name>/<stack-name> (e.g. `acmecorp/dev`).
Stack name (dev):

Then you’ll be shown a list of the package managers to choose from (obviously we’ll use the arrow keys to select the bun option):

The package manager to use for installing dependencies [Use arrows to move, type to filter]
 npm
 pnpm
 yarn
> bun

Hit the ENTER key to make your selection, and you’ll see the bun install output:

The package manager to use for installing dependencies bun
Installing dependencies...

bun install v1.2.18 (0d4089ea)

+ @types/node@18.19.120 (v24.1.0 available)
+ typescript@5.8.3
+ @pulumi/pulumi@3.186.0

272 packages installed [1240.00ms]

Blocked 1 postinstall. Run `bun pm untrusted` for details.
Finished installing dependencies

Your new project is ready to go! ✨

To perform an initial deployment, run `pulumi up`

The files in the folder look a little different:

drwxr-xr-x@ - piers 28 Jul 18:13 node_modules
.rw-r--r--@ 21 piers 28 Jul 18:11 .gitignore
.rw-r--r--@ 61k piers 28 Jul 18:13 bun.lock
.rw-r--r--@ 42 piers 28 Jul 18:11 index.ts
.rw-r--r--@ 217 piers 28 Jul 18:11 package.json
.rw-r--r--@ 198 piers 28 Jul 18:13 Pulumi.yaml
.rw-r--r--@ 438 piers 28 Jul 18:11 tsconfig.json

(note the bun.lock instead of the package-lock.json)

and in the Pulumi.yaml file, the packagemanager option is set to bun:

name: new-bun-project
description: A minimal TypeScript Pulumi program
runtime:
name: nodejs
options:
packagemanager: bun
config:
pulumi:tags:
value:
pulumi:template: typescript

We will use the Random provider to generate a new password. Let’s add the @pulumi/random package:

❯ bun add @pulumi/random
bun add v1.2.18 (0d4089ea)

installed @pulumi/random@4.18.3

[345.00ms] done

Since we’re still using the Pulumi NodeJS runtime, that’s all we need Bun for right now.

The rest is business as usual, so the index.ts file looks like:

import * as random from "@pulumi/random";

const password = new random.RandomPassword("password", {
 length: 20
});

export const pw = password.result;

Then it’s just a case of running:

pulumi up

and creating the resources.

Migrating an existing project

If you already have a project set up and are using npm as your package manager, there are a few steps you’ll need to follow.

For this example, I’m going to use the code from the Bun example above but set it up using npm instead:

❯ pulumi new typescript
This command will walk you through creating a new Pulumi project.

Enter a value or leave blank to accept the (default), and press <ENTER>.
Press ^C at any time to quit.

Project name (migrate-project):
Project description (A minimal TypeScript Pulumi program):
Created project 'migrate-project'

Please enter your desired stack name.
To create a stack in an organization, use the format <org-name>/<stack-name> (e.g. `acmecorp/dev`).
Stack name (dev):

The package manager to use for installing dependencies npm
Installing dependencies...


added 293 packages, and audited 294 packages in 9s

43 packages are looking for funding
 run `npm fund` for details

found 0 vulnerabilities
Finished installing dependencies

Your new project is ready to go! ✨

To perform an initial deployment, run `pulumi up`

Then we’ll install the @pulumi/random package:

npm install @pulumi/random

and checking the folder listing:

drwxr-xr-x@ - piers 28 Jul 18:32 node_modules
.rw-r--r--@ 21 piers 28 Jul 18:32 .gitignore
.rw-r--r--@ 42 piers 28 Jul 18:32 index.ts
.rw-r--r--@ 149k piers 28 Jul 18:32 package-lock.json
.rw-r--r--@ 217 piers 28 Jul 18:32 package.json
.rw-r--r--@ 198 piers 28 Jul 18:32 Pulumi.yaml
.rw-r--r--@ 438 piers 28 Jul 18:32 tsconfig.json

we can see that we’ve got the usual package-lock.json file that we expect, and the Pulumi.yaml file looks like this:

name: migrate-project
description: A minimal TypeScript Pulumi program
runtime:
name: nodejs
options:
packagemanager: npm
config:
pulumi:tags:
value:
pulumi:template: typescript

(Note the packagemanager option).

To migrate this project to use Bun as the package manager instead, we need to update the Pulumi.yaml to set the packagemanager to be bun:

name: migrate-project
description: A minimal TypeScript Pulumi program
runtime:
name: nodejs
options:
packagemanager: bun
config:
pulumi:tags:
value:
pulumi:template: typescript

We can use the bun CLI to migrate the package-lock.json file to the bun.lock file, running the following command:

bun pm migrate

which gives us the file structure:

drwxr-xr-x@ - piers 28 Jul 18:32 node_modules
.rw-r--r--@ 21 piers 28 Jul 18:32 .gitignore
.rw-r--r--@ 64k piers 28 Jul 18:43 bun.lock
.rw-r--r--@ 42 piers 28 Jul 18:32 index.ts
.rw-r--r--@ 149k piers 28 Jul 18:32 package-lock.json
.rw-r--r--@ 217 piers 28 Jul 18:32 package.json
.rw-r--r--@ 198 piers 28 Jul 18:32 Pulumi.yaml
.rw-r--r--@ 438 piers 28 Jul 18:32 tsconfig.json

We can then delete the package-lock.json if we want to.

Then we can run pulumi install to install the packages to Bun’s global cache:

❯ pulumi install
Installing dependencies...

bun install v1.2.18 (0d4089ea)

15 packages installed [60.00ms]
Finished installing dependencies

and continue with

pulumi up

What else?

We’ve baked Bun into the pulumi/pulumi container, allowing you to make use of the faster package installer in your CI/CD pipeline, including in Pulumi Deployments. If you’d like to see Bun become more integrated into Pulumi, there’s an open issue that you can vote on, or even implement if you’re interested.

Final thoughts

Bun is in the process of establishing itself as the new player in the JavaScript ecosystem. Its focus on speed makes it a great alternative to npm, Yarn, and pnpm when managing Pulumi project dependencies. Give it a try on your next project, and you may wonder how you ever lived without it.