@rspack/core

Highlights

Less duplicate code. Smaller bundles.

Rspack's chunking algorithm has been improved to reduce duplicate modules across chunks.

github.com/user-attachments/assets/0840ec5b-7ee…

Smaller package size

Rspack upgrades browserslist-rs and enables deflate compression for its browser data, reducing native binary by 2.13 MB (3.08%).

What's Changed

New Features

• propagate available module growth during code splitting

Performance

• binding: query compilation modules lazily

• avoid transferring unused NormalModuleFactory dependencies

• sources: compact retained source storage

• stats: cache item type strings in StatsFactory

• use a hash set to deduplicate extracted comments

• watcher: avoid per-node concurrent sets in the root analyzer

• share Module and KnownBuildInfo accessors

• optimize placeholder and Node external matching

• sources: profile allocations and trim source map capacity

• sources: release generated value after static source map

• core: cache assetEmitted source and content per info object

• binding: share NormalModule accessors

• share equal factorize path lists by content

• split-chunks: reuse function chunks filter results per chunk set

• binding: materialize module source maps lazily

• share compilation log entry accessors

• cache: restore cached modules off the make main task

• core: share file counter dependency lists by interned content

Bug Fixes

• types: allow void returns in needAdditionalPass hooks

• types: accept falsy loaders and child compiler plugins

• types: allow single loader returns from rule use functions

• preserve interned path sharing in cache serialize

• types: correct Compilation.getAsset return type

• binding: scope importModule publicPath callbacks to compiler

• binding: release transient TSFN callbacks

• types: allow omitting child compiler plugins

• css: load async stylesheets with a shared runtime

• propagate async status through lazy barrel re-exports

• copy: register a missing glob base dir as a missing dependency

• css: end unterminated url() at EOF as a url token

• preserve statement boundaries in modern-module output

• ids: rehash identical keys in compact-hashed ids

• resolve aliases in import.meta.glob patterns

• only source map JS and CSS assets from devtool, matching webpack

• support deferred imports introduced by hot updates

• concatenate empty CommonJS modules without export access

• core: ignore source map directives in JavaScript strings

• css-extract: preserve relative paths from publicPath callbacks

• lazy-compilation: keep import attributes and phase when building activated modules

• lazy-compilation: keep activated modules across rebuilds

• lazy-compilation: keep issuer and resolve options when building activated modules

• watcher: report watched files inside directories that appear

• mf: honor singleton options for shared prefixes in manifests

• watcher: report recreated files by their final state

• preserve pure exports during module concatenation

• resolver: keep RegExp restrictions in ResolverFactory cache key

What's Changed

New Features

• support JavaScript URL entries with factory type probes

• resolver cache in the new cache system

Performance

• core: box optional match resource data

• reduce exports info and parser memory footprint

• core: box optional RSC metadata

• concatenated: store binding references as indices

• reuse compilation dependency arrays and strings

• core: box import attributes

• core: shrink dependency location storage

• core: store module requests as boxed strings

• reduce retained dependency and source capacity

• javascript: share the used-by-exports payload of a dependency

• skip unused code splitting cache copies

• stats: release handles per module while converting stats to JS

Bug Fixes

• types: allow void context module waterfall callbacks

• revert "feat: support JavaScript URL entries with factory type probes"

• preserve deferred evaluation in modern-module output

• resolve: resolve relative tsconfig paths against cwd

• rstest: resolve mock APIs through the runtime registry

• interrupt compaction at cache shutdown

• types: make SharePlugin enhanced option optional

• types: align externals function signatures

• types: correct externals resolver overloads

• reset MultiCompiler done state on watch restart

• types: allow unnamed module federation consumers

• require a name for shared dependency tree shaking

• types: allow stats printer hooks to return void

• types: support custom stats fields in extract hooks

• types: allow shouldEmit hooks to return void

• types: allow Node fs as intermediate file system

• types: accept entry dependencies in ModuleGraph queries

• cli: enable compile cache before loading CLI

• respect CI=false and skip compile cache in CI

• rstest: transform non-hoisted mock APIs in expression position

• avoid retaining source copies in RealContentHash

• loader: avoid mutating lightningcss-loader options

• loader: normalize builtin options for inline requests

Highlights

Smaller bundles with improved code splitting

The new optimization.splitChunks.dedupDepth option lets Rspack spend more build time finding shared code and reducing duplication, giving you more control over the balance between bundle size and build time. In one application with many routes, this option reduced total output size by 9.9%.

It defaults to 1 in production and 0 in development. #15497

Build performance improvements

This release reduces repeated work and allocations during chunk graph construction and CSS Modules class name generation. JavaScript loaders also avoid copying their input content on each invocation, further reducing processing overhead.

• Optimize chunk graph construction: #15278, #15805.

• Reuse metadata and template values when generating CSS Modules class names: #15783, #15804.

• Avoid cloning JavaScript loader content: #15817.

What's Changed

New Features

• split-chunks: add configurable dedupDepth

• file system info path classification

• support nested async dependency blocks

• cache context modules with filesystem snapshots

Performance

• reduce build chunk graph overhead

• css: avoid rebuilding local ident metadata per class name

• resolver: memoize the interned package.json path

• css: cache invariant local ident rendering values

• store runtime keys as SmolStr

• reduce build chunk graph code splitter overhead

• css-extract: avoid per-loader configuration callbacks

• loader: avoid cloning JS loader content

• core: reuse module identifier for identical requests

• loader: statically import worker_threads

• core: reuse resource string for identical user requests

Bug Fixes

• keep shadowing exports bindings in nested runtime deconfliction

• binding: release loader TSFNs on compiler close

• render CommonJS externals directly in modern-module output

• skip entry modules without JavaScript in the chunk startup

• html: keep the doctype when a comment is above it

• types: allow RslibPlugin without options

• ignore fragment-only CSS URL dependencies

• bench: exclude compiler teardown from runtime requirements

• types: declare code generation Sources.get and migrate configs

• types: allow RegExp resolve restrictions and migrate configs

• cli: initialize profiling once for multiple configs

What's Changed

New Features

• loader: support buildInfo custom fields in parallel loaders

Performance

• streamline SplitChunks candidate preparation

• loader: track loader dependencies with sets

• watch: defer internal Watchpack timestamp collection

• replace BigUint with FixedBitSet in code splitter

• use SsoHashSet for small module chunk memberships

• vectorize CSS string and URL scanning with memchr

Bug Fixes

• retain mf manifest expose assets shared with providers

• core: make module source maps context independent

• loader: revert native loader hook invocation

What's Changed

New Features

• expose new cache options and enable cache store in rebuild

Performance

• loader: use one-shot refs for js values

Bug Fixes

• inline runtime chunks with empty names

• align inline loader module types with webpack

• rslib: render externalized new URL targets as plain relative URLs

• rstest: resolve manual mocks next to package entries

• avoid chunk name collisions in compact hashed ids

Highlights

CSS-only entry bundling

CSS-only entries using native CSS support now emit standalone stylesheets without an unnecessary JavaScript bundle. Standalone runtime chunks are also omitted when no JavaScript entry needs them, making it easier to build CSS assets directly. See #14879.

Ignore magic comments in CSS

Native CSS support now recognizes webpackIgnore and its rspackIgnore alias for @import, url(), and image-set() dependencies. This lets you leave selected references for the browser to load instead of resolving and bundling them. See #15314.

Reliable persistent caching for child compilers

With experiments.newCache, parent and child compilers now coordinate access to shared persistent cache storage while keeping their entries separate. This prevents conflicting writes and cleanup from losing cached data, and allows both parent and child modules to be restored across compiler restarts. See #15616.

What's Changed

New Features

• css: support ignore magic comments

• share persistent cache cross child compilers

• support css entry bundling

Performance

• binding: share hook registration code across hook types

Bug Fixes

• mf: infer shared module exports from fallback

• prevent duplicate exports renaming in modern-module output

• preserve shared connections during module concatenation

• binding: expose original source in succeedModule hooks

• normalize HttpUriPlugin allowedUris before matching

• javascript: do not terminate the enclosing scope after a do-while loop

• loader: invoke loader hooks through the native hook

• enforce HttpUriPlugin lockfile integrity in frozen builds

• drop trailing comma when rewriting require.resolve calls

• loader: preserve string BOM across native boundaries

Highlights

CSS Import and Asset URL Externals

Rspack now supports asset, asset-url, and css-import external types, allowing CSS to reference stylesheets and assets hosted elsewhere. External @import statements preserve layer, supports, and media conditions, so conditional styles stay conditional in the emitted CSS. #15431, #15522.

More Flexible and Reliable Native Watching

With experiments.nativeWatcher enabled, watchOptions.ignored now accepts a function, making it easier to reuse existing ignore rules when switching to the native watcher. File event processing has also been improved to reduce event loss during large bursts of changes on Linux. #15254.

Lower Resolution Overhead for TypeScript Projects

Relative imports such as ./utils and ../shared no longer trigger unnecessary tsconfig loading or tracking of its project-reference tree. This reduces configuration reads and dependency tracking, especially in large TypeScript projects with many project references. #15492.

What's Changed

New Features

• cache: align maxMemoryGenerations with webpack

• cache: support builtin swc-loader cache

• watcher: support a function for the native watcher ignored option

• core: expose import attributes on NormalModuleFactory ResolveData

• cache: port webpack persistent module cache

• css: support CSS import and asset URL externals

• error handling for new cache

Performance

• resolver: skip tsconfig paths for relative specifiers

• cache: remove module serialization preflight

Bug Fixes

• treat CJS export assignment as side-effect-free without breaking innerGraph

• ci: speed up dylint and fail on warnings

• preserve leading zeros in string module ids

• devtool: key eval cache by module to keep sourceURL correct

• types: improve loader context filesystem types

• types: allow optionless filesystem sync calls

• javascript: handle shared URL asset runtimes

• copy-plugin: reuse cache for empty rebuilds

• esm: remove empty chunks except for facade chunks

• binding: guard module graph accessors against stale and mid-pass reads

• stabilize incremental missing-module diagnostic location

• prevent recursive module federation shared compilation

• preserve diagnostics returned by importModule

• preserve css-import external conditions

• support Windows DOS device paths

• css: substitute value references in media queries and selectors

• css: skip esm flag for concatenated modules

• ids: stabilize named external module ids

• pre-register modules before chunk graph splitting

What's Changed

New Features

• cache: add intrastructure logging to the new cache

• javascript: add JavascriptModulesPlugin.getChunkFilenameTemplate

Performance

• ids: optimize deterministic module id assignment

• share runtimes in flag dependency usage

• core: optimize module rendering for chunk assets

• core: optimize create module hashes

Bug Fixes

• stats: generate correct prefetch child assets

• keep import.meta.url in createRequire when importMeta is disabled

• core: align module need_build and FileSystemInfo with webpack

• types: support all EnvironmentPlugin default values

• improve incremental chunk graph reuse

• rsdoctor: await patch delivery before sealing completes

• css: ignore exportsOnly in local ident hashes

• fallback eval devtools for modern-module

• report diagnostics for unsupported context modes

Highlights

Corrected compact-hashed IDs naming

Rspack 2.2.0 introduced compact hashed module and chunk IDs under the mistakenly named compat-hashed option and CompatHashedModuleIdsPlugin / CompatHashedChunkIdsPlugin APIs. Rspack 2.2.1 corrects these names to compact-hashed, CompactHashedModuleIdsPlugin, and CompactHashedChunkIdsPlugin.

The names introduced in 2.2.0 remain available as deprecated compatibility aliases, but we recommend upgrading to Rspack 2.2.1 and using the corrected names:

module.exports = {
  optimization: {
    moduleIds: 'compact-hashed',
    chunkIds: 'compact-hashed',
  },
};

What's Changed

New Features

• wasm: align wasmStreamingFallback with webpack

• track dependencies in loader cache

Performance

• core: store FactorizeInfo path dependencies as compact slices

Bug Fixes

• cli: disable stats logging by default

• disable incremental outside development mode

• core: run afterCompile before shouldEmit and asset emission

• cache: clear stale issuer updates between rebuilds

• css: exclude asset output path from URLs

• core: bound concurrent asset writes during emit

• ids: correct compact hashed API names

• rsc: store server compiler ID in native coordinator

• cache: persist dependency id in metadata

• cache: normalize restored paths on Windows

See Announcing Rspack 2.2 for more details.

New Features

• implement generation-based memory cache eviction

• add idle cache compaction with interruption handling

• css: improve unicode handling and support more css modules cases, boost performance

• integrate module code generation to the new cache

• cache: add fine-grained new cache options

• ids: add compat-hashed module ids

• analyze dynamic imports in Promise.all destructuring

• integrate new cache into source map devtool plugin

• core: add compilation.runtimeTemplate

• ids: add compact chunk ids

• loader: support opt-in per-loader caching

Performance

• binding: cache converted module original source

• batch splitChunks JavaScript callbacks

• binding: exclude test loaders from release builds

• binding: exclude perfetto from release WASI builds

• binding: align release WASI optimizations

• binding: optimize React Compiler crates for size

• avoid parsing concatenated module codegen

• preallocate identifier path buffers

• paths: intern ArcPath as a single-allocation prehashed path

• use rayon parallel scheduling for new cache db

• core: skip the directory walk for glob patterns without metacharacters

• split-chunks: skip single-chunk used exports grouping

• core: precompile filename templates cache

Bug Fixes

• pass HMR error to Preact refresh recovery handler

• cache: limit shutdown compaction to a single pass

• types: add missing stats fields

• css-extract: strip BOM from module content before concatenation

• core: decouple incremental artifacts from cache!

• asset: preserve ESM imports in module output for "preserve" importMode

• css: CSS module dashed identifier and composes edge cases

• make Module.blocks and Module.dependencies fail gracefully while the module graph is under construction

• preserve reexport call context in concatenation

• cache: validate new cache version

• cache: use storage location for new cache

• ids: make compare_modules_by_pre_order_index_or_identifier a total order

• await async modules in ProvidePlugin

• refine binding code generation result error handling

• resolver: restore tsconfig files as file dependencies

• include factory-created server actions in RSC metadata

Other Changes

• refactor!(rsc): emit client references directly and preinit CSS

• remove faster module concatenation

[!NOTE]
Removed noisy import.meta warnings

Rspack 2.1.9 introduced warnings for unknown import.meta properties. Because they proved overly noisy in real-world builds, Rspack 2.1.10 removes them to reduce unnecessary diagnostics for custom or runtime-specific extensions. See #15166 for detail.

What's Changed

New Features

• expose ExternalModule chunkCondition hook

• new cache system

• integrate new cache to minimize cache

Bug Fixes

• split-chunks: process remaining module copies at lower priorities

• esm_library: allow scope hoisting for new URL targets in new-url-relative mode

• cli: normalize string context from loaded config

• share ExternalModule hooks across core instances

• new cache compile failed on 32-bit platforms

Other Changes

• unknown import.meta property warnings

What's Changed

New Features

• warn on unknown import.meta properties

• add builds for binding-linux-(ppc64,s390x)-gnu

• create-rspack: support --no-git

• support caseSensitive in import.meta.glob

Performance

• copy-plugin: cache and order static patterns

• limit incremental HMR asset processing

• avoid unnecessary call wrappers for runtime helpers

• cache compilation assets proxy

• cache: avoid copying aligned archive buffers

• json: avoid duplicating export dependency data

• improve source map convert performance

Bug Fixes

• improve circular real content hash error diagnostics

• keep compilation dependency iterators disjoint

• cache: align cache version semantics with webpack

• preserve ignored URL when import.meta.url is disabled

• napi: avoid runtime lock deadlock

• lazy: match compiler prefixes exactly

• mf: avoid injecting shared providers into worker entrypoints

• handle optional chains in member hook traversal

• support loader context APIs in parallel loaders

• warn on invalid chunk names

• preserve imports in impure class expressions

• preserve worker entrypoints when async chunks are disabled

• align loader context docs and types with implementation

• rstest: make import.meta.rstest resolver optional

• handle context changes in import.meta.glob hooks

• types: align public API docs with declarations

• preserve worker entrypoints during module deduplication

• cli: restore config key completions in defineConfig

• deduplicate parse errors by source range

Highlights

Persistent cache storage options now align with webpack

Rspack now supports cache.name and cache.storage.location, aligning with webpack's persistent cache semantics. cache.storage.directory is now the base directory, while the final cache location defaults to <directory>/<cache.name>. Default cache paths remain unchanged.

If you previously used storage.directory as the exact cache path, migrate it to storage.location. Existing cache data is not migrated automatically.

cache: {
  type: 'persistent',
  storage: {
    type: 'filesystem',
-   directory: '/custom/cache',
+   location: '/custom/cache',
  },
}

What's Changed

New Features

• rstest: inject module origin for import.meta.rstest

• align persistent cache storage options with webpack

• hmr: emit css.c / css.r in the hot-update manifest for precise CSS updates

Performance

• avoid cloning Lightning CSS stylesheet AST

• avoid cloning CSS module lists during ordering

• copy: offload asset reads

• share source across linking diagnostics

Bug Fixes

• binding: preserve entry dependency identity

• loader: preserve lightningcss license comments

• esm: add missing CJS interop runtime requirement

• runtime: avoid dead require bootstrap

• runtime: preserve collision-free createRequire imports

• clean up compilation-scoped plugin caches

• rstest: hoist test API imports by source order

• binding: release custom runtime module generators on close

• preserve context exports in rspack runtime mode

• runtime: correct full-hash chunk filenames

• copy-plugin: use POSIX asset keys

• runtime: remove redundant runtime declarations

• worker: handle SharedWorker string name option

• avoid runtime scope conflicts in module factories

• preserve direct exports bindings

• dll: serialize buildMeta.defaultObject as redirect-warn

• json: match webpack source map behavior for generated modules

• keep property name when global is used in object shorthand

• prevent compiler abort for exported rspackRequire

Notice: The import.meta.env experimental feature introduced in Rspack 2.1.6 has been removed in Rspack 2.1.7.

What's Changed

Performance

• share source code across diagnostics

Bug Fixes

• revert "feat: support import.meta.env"

• binding: release module graph connection wrappers

What's Changed

New Features

• support import.meta.env

Performance

• cache module concatenation analysis across roots

• reuse module concatenation search state

• reduce module concatenation hot-path overhead
  in #14834

Bug Fixes

• materialize namespace object for concatenated modules

• parse preserved createRequire arguments

• invalidate module hashes when assigning deterministic and natural ids

• disable incremental chunk assets for entry fullhash filenames

• propagate asset emit errors

• asset: avoid JavaScript output for URL-only assets

• rslib: avoid worker external facade in bundleless output

• execute worker entry modules in modern-module output

• cli: preserve defineConfig inference

• swc-loader: preserve structured swc diagnostics

• respect DllPlugin context for concatenated modules

• ci: resolve the binary-size base for stacked PRs

• cache: scope maxVersions by compiler using compilerPath