Bun 1.3 launches a unified, batteries-included full-stack JavaScript runtime—here's how to use it now

Bun 1.3's release cuts through the noisy landscape of full-stack JavaScript runtimes by nailing both speed and built-in scope. According to the official Bun v1.3 release post — which bills it as Bun's biggest release yet — you can now run, build, test, install, bundle, and serve from a single binary, with built-in database clients and a full-stack dev server included. One runtime, one CLI, and local dev, CI, and prod start to look like a single path instead of three loosely related setups.

This is a retrofit of our original Bun 1.3 walkthrough: same hands-on structure, with claims re-checked against the official release notes, fuzzy specifics trimmed, and sources added throughout.

Why Bun 1.3 matters for full-stack JavaScriptCopy Anchor Link

Bun 1.3 bundles more than a fast runtime. It ships native tooling for jobs that historically demanded a grab bag of dependencies: a test runner, a bundler, a package manager, TypeScript support with no explicit build step, and a dev server with hot reload built into Bun.serve(), per the release post. Cold starts stay fast because Bun skips the traditional node_modules overhead with its own linker, and environment startup avoids the lockfile waits and scanner passes that slow down typical Node setups.

The philosophical break is what matters most: instead of "everything is a module," Bun ships batteries-included. Whether that pressures legacy Node stacks and alternatives like Deno is a matter of opinion — ours is that collapsing five tools into one binary removes real, daily friction — but the mechanism is concrete either way. Fewer moving parts means less dependency sprawl, which translates directly into smaller bug surface and faster CI.

If you are building services or apps and want setup to mirror production as closely as possible, this is the version where that promise gets serious.

Built-in developer tooling: one CLI for the whole loopCopy Anchor Link

Bun 1.3 puts the test runner, REPL, bundler, and package manager behind the same CLI surface. No polyfills, no wrappers — one-call commands you already know:

bun test

This detects and runs your project's tests, recognizing .test.{js,ts} and .spec.{js,ts} patterns with Bun's own runner — visibly faster than a Jest-on-Node equivalent for typical suites.

TypeScript runs directly, no tsc step:

bun run src/app.ts

Native TypeScript applies across the runner, the REPL, and the bundler. Exploration is one command away:

bun repl

TypeScript input works natively with Bun APIs in scope, so any API surface is explorable in seconds.

For production, bun build bundles full projects — dependencies and assets included — down to a single executable:

bun build src/index.ts --compile --outfile=dist/app

That binary can be copied and run anywhere Bun runs, which makes deploys a file copy instead of a dependency-install ceremony. A whole error class — wrong node_modules, missed asset copies, mismatched bundler flags between laptop and CI — drops out of the workflow, because development and production builds follow the same code path. That deliberate choice is the direct answer to the "works in dev, fails in prod" trap.

Getting started keeps the project's signature zero-friction install:

curl -fsSL https://bun.sh/install | bash

The official install page covers platform specifics. From a clean checkout, bun install plus bun dev gets a typical project running in seconds rather than minutes.

Built-in database clients: backend without the glueCopy Anchor Link

One of the release's most practical additions is first-party database support: built-in clients for PostgreSQL, MySQL, and SQLite plus Redis, according to the release post. These are native implementations rather than polyfilled Node modules, which means real performance and better error fidelity — and no node-gyp build step, no native-module compilation, no thirty-second installs just to talk to a database.

The effect on backend setup time is hard to overstate. The usual tangle of client libraries, wrappers, and ORM glue for a simple query collapses to an import and a connection string, and test, dev, and prod environments stay consistent down to the wire protocol. For the exact client APIs and connection options, read the official release notes — client surface details evolve, and the release post is the reference that stays current.

Serving and shipping: the converged surfaceCopy Anchor Link

Serving built assets needs no dedicated package, and the release adds the ability to run HTML files directly — static sites and previews come straight out of the same binary. Combined with --compile output, the full loop from first bun install to a shippable artifact never leaves the Bun CLI:

bun install
bun dev
bun test
bun build src/index.ts --compile --outfile=dist/app

For teams coming from slow Node, webpack, and tsc pipelines, the weekly savings are measured in hours per engineer — not from any single trick, but from removing the seams between tools.

Where Bun fits in a shippable stackCopy Anchor Link

Fast loops are necessary but not sufficient. The persistent parts of a backend — user state, secrets, audit trails, infrastructure config — deserve a stability layer that does not move when your runtime does. That is the division of labor worth adopting: shape and iterate in Bun while the spec moves fast, and anchor persistence behind durable, portable layers. If your repo is already agent-readable, agents can drive the whole Bun loop for you. If your path from MVP to production is short, every millisecond Bun saves compounds instead of evaporating into deploy ceremony. And if one codebase serves every platform, the things you build at Bun speed are shippable everywhere.

OTF kits are built for exactly that shape: full-stack templates your AI coding agent can take from prompt to production without a rewrite step. Start from a kit that ships.

SourcesCopy Anchor Link

• Bun v1.3 release post — official: biggest release yet, full-stack dev server with hot reload in Bun.serve(), built-in MySQL/Postgres/SQLite and Redis clients, run HTML files directly.
• Bun install page — official install path.
• Agent-readable repository structure — repos agents can drive at Bun speed.
• Ship your AI MVP to production checklist — keeping the deploy path short.
• One codebase across web and mobile — shippable output on every surface.