Skip to the content
Know your tech before you buy it. Makers: get listed from $49/mo

Turbopack

nextjs.org

  • Free plan
  • Windows
  • macOS
  • Linux
7.3 Club score Visit nextjs.org

What Turbopack is

Turbopack is an incremental JavaScript and TypeScript bundler written in Rust and built into Next.js. It supports local development with both the Pages Router and App Router, and is the default bundler in Next.js for basic use without configuration. It parallelizes work across CPU cores, caches results at the function level and persists results to disk between runs. Lazy bundling handles only what the development server requests, which can reduce initial compile time and memory use. Supported languages and formats include JavaScript, TypeScript, ECMAScript, CommonJS and ESM; it also detects Babel configuration in Next.js 16. Framework support includes JSX, Fast Refresh and React Server Components for the App Router. Styling options include global CSS, CSS Modules, nesting, PostCSS and Sass/SCSS, but not custom Sass functions. It supports static image and font imports, JSON imports, aliases and custom extensions. Native bindings are available for macOS, Windows and Linux on x64 and ARM64. Turbopack is included in Next.js with no separate price stated. It does not perform TypeScript type checking, and it does not support webpack plugins.

Who it suits

Turbopack suits developers building with Next.js who want an incremental bundler for local development and whose projects fit its supported integrations and styling options.

Good to know, and what to watch

  • Default bundler in Next.js for basic use.
  • Works with Pages Router and App Router.
  • Caches results at function level and between runs.
  • Supports Fast Refresh and React Server Components.
  • Available on macOS, Windows and Linux.
  • Does not perform TypeScript type checking.
  • Does not support webpack plugins.
  • Custom Sass functions are unsupported.
  • Yarn Plug'n'Play is not planned for support.

Turbopack

Free

Free plan

The Club's review

Turbopack is a Rust-built incremental bundler integrated into Next.js for JavaScript and TypeScript development. It is best for teams using either Next.js router who want faster repeat compilation without maintaining a separate bundler setup. Projects tied to webpack plugins or requiring built-in type checking should look beyond it.

Overview

Turbopack is the default Next.js bundler, and basic projects can use it without configuration. It supports local development with both the Pages Router and App Router, making it a sensible baseline for conventional Next.js applications rather than another build system to wire in.

Its incremental engine parallelizes work across CPU cores, caches results at function level, and keeps those results on disk between runs. Unchanged work can therefore stay out of repeated development builds. Lazy bundling compiles only modules requested by the development server, which can reduce the first compile's time and memory use. Those advantages matter most on large or frequently edited codebases; they do not remove compatibility concerns for projects built around unsupported extensions.

Key features

Language and Next.js support

JavaScript, TypeScript, ECMAScript, CommonJS and ESM are supported, with Babel configuration detection in Next.js 16. JSX, Fast Refresh and React Server Components work with the App Router. This covers the normal Next.js development loop, including rapid browser updates and server-component workflows.

Styles and assets

Global CSS, CSS Modules, CSS nesting, PostCSS and Sass/SCSS are supported. Custom Sass functions are not. Static image and font imports, JSON imports, TypeScript path aliases, manual aliases and custom extensions are also handled, so common asset and resolution patterns do not require a separate bundling layer.

Build behavior and capabilities

Function-level caching, persistent disk caching and parallel execution target the repeated rebuilds that consume developer time. Lazy bundling avoids compiling code the development server has not requested. Turbopack also provides code splitting, tree shaking and source maps, useful for separating output, removing unused code and tracing generated code during development.

Integration boundaries

Turbopack supports webpack loaders but not webpack plugins. That distinction is decisive for applications whose build pipeline depends on plugin APIs. Yarn Plug'n'Play and experimental URL imports are not planned for Turbopack support in Next.js, further narrowing its fit for projects built around those mechanisms.

TypeScript workflow

Turbopack does not perform TypeScript type checking. Teams must run tsc --watch or use an IDE alongside the bundler. That split keeps bundling focused on development output, but it adds a required process to any workflow that expects compile-time type validation.

Pricing

PlanPriceWhat it includes
TurbopackFreeIncluded in Next.js; no separate price stated

The free plan is the complete published offering, with no paid tiers or seat and quota terms stated. It suits individual developers and teams already building with Next.js that want the default development bundler without an additional software bill.

Platforms

Native bindings are available on macOS, Windows and Linux for x64 and ARM64 systems. Linux support covers both glibc and musl. That combination accommodates common developer workstations and Linux environments without restricting the choice to one processor family.

Who it's for

Turbopack is a strong choice for Next.js teams using standard JavaScript or TypeScript workflows, whether they work in the Pages Router or App Router. It is particularly suitable when repeated local rebuilds, initial compile cost or memory use are visible productivity issues, and when zero-configuration defaults are preferable.

Choose another bundler when webpack plugins are central to the application, when Yarn Plug'n'Play or experimental URL imports are required, or when type checking must be part of the bundler itself. The need to run a separate TypeScript watcher is manageable, but it should be part of the team's normal development setup.

Pros and cons

Pros

  • Default Next.js integration: Basic projects can start without bundler configuration, with support for both routing systems.
  • Efficient incremental work: Parallel execution, function-level caching and persistent disk results reduce repeated compilation.
  • Lower-demand startup: Lazy bundling can limit initial compilation time and memory use by compiling requested code only.
  • Broad everyday coverage: Core languages, JSX, Fast Refresh, React Server Components, common CSS systems, assets and aliases are supported.
  • Flexible native coverage: macOS, Windows and Linux are supported on x64 and ARM64, including glibc and musl Linux.

Cons

  • No webpack plugins: Loader compatibility does not help projects that depend on webpack's plugin API.
  • No built-in type checking: TypeScript validation requires tsc --watch or an IDE in parallel.
  • Known integration gaps: Yarn Plug'n'Play and experimental URL imports are not planned for support.
  • Sass limitation: Custom Sass functions are unsupported even though Sass/SCSS itself works.

Alternatives

Rolldown is a free, open-source option for teams wanting a separate bundler across Linux, macOS, Windows, Android, web and API environments.

Rslib is a free, MIT-licensed open-source choice when a standalone tool with broad desktop, web and API platform coverage is preferred.

Vite is a free, MIT-licensed open-source alternative for projects seeking a separate development tool on Linux, macOS, Windows and the web.

SWC is a free, open-source Rust-based developer toolchain with wider listed platform coverage.

esbuild is free MIT-licensed software available as a native executable or WebAssembly version, with no paid tiers stated.

Terser is a free JavaScript minifier toolkit rather than an integrated Next.js default.

Rspack is a free, MIT-licensed open-source alternative for teams that need a separate bundler.

Google Closure Compiler is a free, open-source Java application, Bazel library and NPM package.

Compare JavaScript build tools if Turbopack's Next.js focus does not match your stack.

Verdict

Choose Turbopack for Next.js development when incremental local builds, lazy compilation and a no-configuration default are the priorities. Its free inclusion and broad Next.js feature coverage make it the practical starting point for standard projects. Look elsewhere if webpack plugins, unsupported import workflows or integrated TypeScript checking are non-negotiable.

The verdict

Turbopack offers incremental bundling and a broad set of Next.js development capabilities, with no separate price stated. Plan separate TypeScript checks and confirm that its integration limits fit your project.

What the maker publishes

Asset and resolution support
It supports static image and font imports, JSON imports, TypeScript path aliases, manual aliases, and custom extensions. source
CSS and styling
It supports global CSS, CSS Modules, CSS nesting, PostCSS, and Sass/SCSS in Next.js; custom Sass functions are unsupported. source
Default bundler
Turbopack is the default bundler in Next.js, with no configuration required for basic use. source
Framework features
It supports JSX, Fast Refresh, and React Server Components for the Next.js App Router. source
Incremental builds
It parallelizes work across CPU cores, caches results at the function level, and persists results to disk between runs. source
Integration limit
Turbopack does not support webpack plugins, although it supports webpack loaders. source
Language support
It supports JavaScript, TypeScript, ECMAScript, CommonJS, ESM, and Babel configuration detection in Next.js 16. source
Lazy bundling
It bundles only what the development server requests, which can reduce initial compile time and memory use. source
Other limitations
Yarn Plug'n'Play and experimental URL imports are not planned for Turbopack support in Next.js. source
Purpose
Turbopack is an incremental JavaScript and TypeScript bundler written in Rust and built into Next.js. source
Support channel
The documentation says users can attach a generated Turbopack trace file when filing a GitHub issue to help the Next.js team investigate performance or memory issues. source
Supported systems
Native bindings are available for macOS, Windows, and Linux on x64 and ARM64; Linux supports glibc and musl. source
Type checking
Turbopack does not perform TypeScript type checking; the documentation recommends running tsc --watch or using an IDE for checks. source
Use
It supports both the Pages Router and App Router for local development. source

Checked against the maker's pages on 7 Oct 2026.