Building a TypeScript Library in 2025

If you’ve built a TypeScript library recently, you know the pain. You spend more time wrestling with build configurations than actually writing code. Your tsup builds take 4 seconds.

It’s 2025. We can do better.

The TypeScript ecosystem has been missing a tool that combines:

• Lightning-fast builds (sub-100ms, not multi-second)
• Zero-config ergonomics that scale with complexity
• Modern TypeScript features like isolatedDeclarations
• Built-in intelligence for common library tasks

Enter the Speed Revolution

Here’s what modern TypeScript library development should look like:

# Traditional approach
$ tsup src/index.ts
✓ Build completed in 1.4s

# What's possible in 2025 with bunup
$ bunup src/index.ts
✓ Build completed in 37ms

37 milliseconds. Not 1.8 seconds. Not 400ms. 37ms.

Bunup is powered by Bun’s native bundler, making it fast by default with instant TypeScript declaration generation.

This isn’t just about saving time (though saving 1.7+ seconds per build adds up). It’s about changing how you develop. When builds are instant, you can:

• Iterate faster during development
• Run builds in watch mode without battery drain
• Include builds in pre-commit hooks without friction
• Actually enjoy the development process

Modern TypeScript: Isolated Declarations

TypeScript 5.5 introduced isolatedDeclarations – a game-changer for library authors that most tools still don’t properly support.

Why It Matters

Traditional declaration generation analyzes your entire codebase to infer types:

// Old way - requires whole-program analysis
export function getUserData(id: string) {
  return database.users.find(user => user.id === id); // Inferred return type
}

With isolatedDeclarations, you’re explicit about your public API:

// Modern way - explicit, fast, reliable
export function getUserData(id: string): Promise<User | null> {
  return database.users.find(user => user.id === id);
}

The Benefits

• 10x faster declaration generation
• More predictable types for library consumers
• Better encapsulation – your internal types stay internal
• Clearer intent – you explicitly define what’s public

Enable it in your tsconfig.json:

{
  "compilerOptions": {
    "declaration": true,
    "isolatedDeclarations": true
  }
}

Modern bundlers should embrace this, not fight it.

Beyond Speed: Beautiful Ergonomics

Fast builds are just the beginning. Modern library tooling should understand your needs:

Package Exports

// bunup.config.ts
export default defineConfig({
  entry: ['src/index.ts'],
  plugins: [exports()]
});

Your package.json automatically gets:

{
  "main": "./dist/index.cjs",
  "module": "./dist/index.js", 
  "types": "./dist/index.d.ts",
  "exports": {
    ".": {
      "import": {
        "types": "./dist/index.d.ts",
        "default": "./dist/index.js"
      },
      "require": {
        "types": "./dist/index.d.cts", 
        "default": "./dist/index.cjs"
      }
    }
  }
}

No more manual exports field maintenance. No more forgetting the types field. No more mismatched paths.

Unused Dependencies

plugins: [unused()]

Get warnings about:

• Dependencies you’re not actually using
• Dev dependencies that should be regular dependencies
• Missing peer dependencies

And a lot more beautiful plugins that you love.

Monorepo Support

Building multiple packages? Bunup workspaces make it effortless:

// bunup.config.ts
export default defineWorkspace([
  {
    name: "core",
    root: "packages/core",
    config: { entry: ["src/index.ts"], format: ["esm", "cjs"] }
  },
  {
    name: "utils", 
    root: "packages/utils",
    config: { entry: ["src/index.ts"], format: ["esm"] }
  }
]);

Build all packages with a single command, with incremental builds that only rebuild what’s changed. Perfect for design systems, component libraries, and complex projects.

The Full Developer Experience

Here’s what building a TypeScript library looks like in 2025:

Initial Setup (10 seconds)

bunx bunup@latest --new

You get:

• TypeScript configured with isolatedDeclarations
• Bun-powered testing setup
• Biome for linting and formatting
• GitHub Actions for CI/CD
• Automatic npm publishing workflow

Development Workflow

bun run dev    # Watch mode with instant rebuilds
bun run test   # Lightning-fast tests
bun run build  # Production build in ~37ms

Publishing

bun run release

Automatically:

• Bumps version
• Generates changelog
• Creates GitHub release
• Publishes to npm with provenance

Real-World Performance Comparison

I tested this with a medium-sized TypeScript library (15 source files, 3 entry points):

That’s not a typo. 37 milliseconds for a complete build with TypeScript declarations.

⭐ Star bunup on GitHub and join the speed revolution.

The future of TypeScript library development is here. It’s fast, it’s simple, and it’s available at bunup.dev today.