> For AI agents: the complete documentation index is available at /llms.txt, the full documentation bundle is available at /llms-full.txt, and this page is available as Markdown at /config/optimization.md.

CC 4.0 License

> The content of this section is derived from the content of the following links and is subject to the CC BY 4.0 license.
> 
> - [https://webpack.js.org/configuration/optimization/](https://webpack.js.org/configuration/optimization/)
> 
> The following contents can be assumed to be the result of modifications and deletions based on the original contents if not specifically stated.
> 
> 


# Optimization

Rspack will select appropriate optimization configuration based on the [`mode`](/config/mode.md). You can also customize the configuration via [`optimization`](/config/optimization.md).

## optimization.avoidEntryIife


[Added in v1.2.0](https://github.com/web-infra-dev/rspack/releases/tag/v1.2.0)


- Type: `boolean`
- Default:`false`


Use `optimization.avoidEntryIife` to avoid wrapping the entry module in an IIFE when it is required (search for `"This entry needs to be wrapped in an IIFE because"` in [rspack\_plugin\_javascript](https://github.com/web-infra-dev/rspack/blob/main/crates/rspack_plugin_javascript/src/plugin/mod.rs)). This approach helps optimize performance for JavaScript engines and helps tree shaking when building ESM libraries.

Currently, `optimization.avoidEntryIife` can only optimize a single entry module along with other modules.

```js title="rspack.config.mjs"
export default {
  optimization: {
    avoidEntryIife: true,
  },
};
```

:::warning
The `⁠optimization.avoidEntryIife` option can negatively affect build performance. If you prioritize build performance over these optimizations, consider not enabling this option.
:::

## optimization.chunkIds


- Type: `'natural' | 'named' | 'deterministic' | 'size' | 'total-size'`
- Default:[development mode](/config/mode#development) is`'named'`, [production mode](/config/mode#production) is`'deterministic'`


Tells Rspack which algorithm to use when generating chunk ids.

The following string values are supported:

| option            | description                                                                                                                                    |
| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `'natural'`       | Use numeric ids in order of usage.                                                                                                             |
| `'named'`         | Readable ids for better debugging.                                                                                                             |
| `'deterministic'` | Short numeric ids which will not be changing between compilation. Good for long term caching. By default a minimum length of 3 digits is used. |
| `'size'`          | Use numeric ids to make the initial download package smaller.                                                                                  |
| `'total-size'`    | Use numeric ids to make the overall download package smaller.                                                                                  |

```js title="rspack.config.mjs"
export default {
  optimization: {
    chunkIds: 'deterministic',
  },
};
```

## optimization.concatenateModules


- Type: `boolean`
- Default:[production mode](/config/mode#production) is`true`, [development mode](/config/mode#development) is`false`


Tells Rspack to find segments of the module graph which can be safely concatenated into a single module. Depends on [optimization.providedExports](#optimizationprovidedexports) and [optimization.usedExports](#optimizationusedexports). By default `optimization.concatenateModules` is enabled in `production` mode and disabled elsewise.

```js title="rspack.config.mjs"
export default {
  optimization: {
    concatenateModules: false,
  },
};
```

## optimization.emitOnErrors


- Type: `boolean`
- Default:[production mode](/config/mode#production) is`false`, [development mode](/config/mode#development) is`true`


Use the `optimization.emitOnErrors` to emit assets whenever there are errors while compiling. This ensures that erroring assets are emitted. The errors are emitted into the generated code and will cause errors at runtime.

```js title="rspack.config.mjs"
export default {
  optimization: {
    emitOnErrors: true,
  },
};
```

## optimization.inlineExports


[Added in v1.7.0](https://github.com/web-infra-dev/rspack/releases/tag/v1.7.0)


- Type: `boolean`
- Default:[production mode](/config/mode#production) is`true`, [development mode](/config/mode#development) is`false`


Performs cross-module inline optimization for:

1. Exported top-level constant values that can be statically evaluated:
   - `null` or `undefined`
   - `boolean` values (`true` or `false`)
   - `number` with length \<= 6
   - `string` with length \<= 6

2. Exported TypeScript enums that collected by [`builtin:swc-loader collectTypeScriptInfo.exportedEnum`](/guide/features/builtin-swc-loader.md#collecttypescriptinfoexportedenum)

This optimization helps reduce bundle size and can improve runtime performance.

A common use case is with `constants.js` files:

```js
// constants.js
export const A = true;
export const B = 'hello';

// index.js
import { A, B } from './constants';
console.log(A ? 1 : 2);
console.log(B.length);
```

When `inlineExports` is enabled, constant values will be inlined at their usage sites:

```js
// Bundled by Rspack: output.js
const __webpack_modules__ = {
  './index.js': () => {
    // Constants are inlined directly
    console.log(true ? 1 : 2);
    console.log('hello'.length);
    // If all exports from constants.js are inlined, the constants.js module
    // will be optimized away and won't appear in the final output
  },
};
```

:::tip
Since this feature relies on module export usage information ([optimization.usedExports](#optimizationusedexports)), it is recommended to enable it only in production mode where `usedExports` is enabled by default.
:::

:::warning TDZ behavior
Inlining constant exports from modules in circular dependencies may change code that would otherwise throw a temporal dead zone (TDZ) error so that it no longer throws. Most tools in the ecosystem generally do not preserve TDZ errors when optimizing; Rspack also follows this optimization-first behavior.
:::

For more details, refer to the [inline const example](https://github.com/rstackjs/rstack-examples/tree/main/rspack/inline-const).

## optimization.innerGraph


- Type: `boolean`
- Default:[production mode](/config/mode#production) is`true`, [development mode](/config/mode#development) is`false`


`optimization.innerGraph` tells Rspack whether to perform a more detailed analysis of variable assignments. This helps Rspack to identify unused module exports, thereby reducing the size of the bundled output.

For example:

```js
import { value } from 'lib';

const value2 = value;

function f1() {
  console.log(value);
}

function f2() {
  console.log(value2);
}
```

Here we assign the `value` to `value2`. Both `value2` and `value` are accessed within the functions `f2` and `f1` respectively, but the functions are not called, hence `value2` and `value` are not actually used, thus the import of `value` can be removed.

## optimization.mangleExports


- Type: `boolean | 'deterministic' | 'size'`
- Default:[production mode](/config/mode#production) is`true`, [development mode](/config/mode#development) is`false`


`optimization.mangleExports` controls how export names are mangled.

The following values are supported:

| option            | description                                                                                                    |
| ----------------- | -------------------------------------------------------------------------------------------------------------- |
| `'size'`          | Use the shortest possible export names to reduce bundle size.                                                  |
| `'deterministic'` | Use short and stable export names for better long-term cache stability. Enabled by default in production mode. |
| `true`            | Same as `'deterministic'`.                                                                                     |
| `false`           | Disable export mangling and keep original export names. Enabled by default in development mode.                |

For example, with the following source code:

```js title="src/math.js"
export const veryLongExportName = 1;
```

When `mangleExports` is disabled, the export name is preserved:

```js title="dist/main.js"
__webpack_require__.d(__webpack_exports__, {
  veryLongExportName: () => veryLongExportName,
});
```

When `mangleExports` is set to `'size'`, the export name is shortened:

```js title="rspack.config.mjs"
export default {
  optimization: {
    mangleExports: 'size',
  },
};
```

```js title="dist/main.js"
__webpack_require__.d(__webpack_exports__, {
  a: () => veryLongExportName,
});
```

## optimization.mergeDuplicateChunks


- Type: `boolean`
- Default:`true`


Whether to merge chunks which contain the same modules. Setting `optimization.mergeDuplicateChunks` to `false` will disable this optimization.

```js title="rspack.config.mjs"
export default {
  optimization: {
    mergeDuplicateChunks: false,
  },
};
```

## optimization.minimize


- Type: `boolean`
- Default:[production mode](/config/mode#production) is`true`, [development mode](/config/mode#development) is`false`


Whether to use the minimizer declared in [`optimization.minimizer`](#optimizationminimizer) to minimize the bundle.

```js title="rspack.config.mjs"
export default {
  optimization: {
    minimize: true,
  },
};
```

## optimization.minimizer


- Type: `('...' | Plugin)[]`
- Default:`[new SwcJsMinimizerRspackPlugin(), new LightningCssMinimizerRspackPlugin()]`


Customize the minimizer. By default, [`rspack.SwcJsMinimizerRspackPlugin`](/plugins/rspack/swc-js-minimizer-rspack-plugin.md) and [`rspack.LightningCssMinimizerRspackPlugin`](/plugins/rspack/lightning-css-minimizer-rspack-plugin.md) are used.

When `optimization.minimizer` is specified, the default minimizers will be disabled.

```js title="rspack.config.mjs"
import TerserPlugin from 'terser-webpack-plugin';

export default {
  optimization: {
    minimizer: [new TerserPlugin()],
  },
};
```

Use Rspack's built-in minimizer with custom options:

```js title="rspack.config.mjs"
import { rspack } from '@rspack/core';

export default {
  optimization: {
    // when `optimization.minimizer` is specified, the default minimizers are disabled by default
    // but you can use '...', it represents the default minimizers
    minimizer: [
      new rspack.SwcJsMinimizerRspackPlugin({
        minimizerOptions: {
          format: {
            comments: false,
          },
        },
      }),
      new rspack.LightningCssMinimizerRspackPlugin({
        minimizerOptions: {
          errorRecovery: false,
        },
      }),
    ],
  },
};
```

## optimization.moduleIds


- Type: `false | 'natural' | 'named' | 'deterministic' | 'hashed'`
- Default:[production mode](/config/mode#production) is`'deterministic'`, [development mode](/config/mode#development) is`'named'`


Tells Rspack which algorithm to use when generating module ids.

The following string values are supported:

| option          | description                                                                                                                    |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `natural`       | Use numeric ids in order of usage.                                                                                             |
| `named`         | Use meaningful, easy-to-debug content as id.                                                                                   |
| `deterministic` | Use the hashed module identifier as the id to benefit from long-term caching. By default a minimum length of 3 digits is used. |
| `hashed`        | Use hashed module identifiers as ids. Equivalent to using `HashedModuleIdsPlugin` with default options (md4, base64, 4 chars). |
| `false`         | Disable Rspack's built-in module id algorithm, allowing a custom plugin to provide module ids.                                 |

```js title="rspack.config.mjs"
export default {
  optimization: {
    moduleIds: 'deterministic',
  },
};
```

The `deterministic` option is useful for long term caching, and results in smaller bundles compared to hashed. Length of the numeric value is chosen to fill a maximum of 80% of the id space. By default a minimum length of 3 digits is used when `optimization.moduleIds` is set to `deterministic`.

## optimization.nodeEnv

- **Type:** `string | false`
- **Default:** Determined by [`mode`](/config/mode.md):
  - [`production` mode](/config/mode.md#production): `'production'`
  - [`development` mode](/config/mode.md#development): `'development'`
  - [`none` mode](/config/mode.md#none): `false`

`optimization.nodeEnv` controls the value used to replace `process.env.NODE_ENV` at compile time. Rspack performs this replacement with [DefinePlugin](/plugins/webpack/define-plugin.md).

You can override the mode-dependent default with either of the following values:

- Any string: replace `process.env.NODE_ENV` with the specified string.
- `false`: disable the replacement and leave `process.env.NODE_ENV` unchanged.

```js title="rspack.config.mjs"
export default {
  optimization: {
    nodeEnv: 'production',
  },
};
```

## optimization.providedExports


- Type: `boolean`
- Default:`true`


After enabling, Rspack will analyze which exports the module provides, including re-exported modules. A warning or error will be issued when importing members that reference non-existent exports. By default, `optimization.providedExports` is enabled. This analysis will increase build time. You may consider disabling this configuration in development mode. Disabling it may lead to errors related to runtime circular dependencies as mentioned in the [SideEffects section](/guide/optimization/tree-shaking.md#re-export-analysis).

```js title="rspack.config.mjs"
export default {
  optimization: {
    providedExports: false,
  },
};
```

## optimization.realContentHash


- Type: `boolean`
- Default:[production mode](/config/mode#production) is`true`, [development mode](/config/mode#development) is`false`


Adds an additional hash compilation pass after the assets have been processed to get the correct asset content hashes. This feature will enable by default in production mode.

If realContentHash is set to false, internal data is used to calculate the hash and it can change when assets are identical in some cases.

```js title="rspack.config.mjs"
export default {
  optimization: {
    realContentHash: true,
  },
};
```

## optimization.removeEmptyChunks


- Type: `boolean`
- Default:`true`


Detect and remove empty chunks generated in the compilation. Setting `optimization.removeEmptyChunks` to `false` will disable this optimization.

```js title="rspack.config.mjs"
export default {
  optimization: {
    removeEmptyChunks: false,
  },
};
```

## optimization.runtimeChunk


- Type: `boolean | 'single' | 'multiple' | { name?: string | ((entrypoint: { name: string }) => string) }`
- Default:`false`


Used to control how the Rspack's [runtime](/misc/glossary.md#runtime) chunk is generated.

Defaults to `false`, which means the runtime code is inlined into the entry chunks.

Setting it to `true` or `'multiple'` will add an additional chunk containing only the runtime for each entry point. This setting is an alias for:

```js title="rspack.config.mjs"
export default {
  optimization: {
    runtimeChunk: {
      name: (entrypoint) => `runtime~${entrypoint.name}`,
    },
  },
};
```

Setting it to `'single'` will extract the runtime code of all entry points into a single separate chunk named `runtime`. This setting is an alias for:

```js title="rspack.config.mjs"
export default {
  optimization: {
    runtimeChunk: {
      name: 'runtime',
    },
  },
};
```

By setting `optimization.runtimeChunk` to an object it can provide an optional `name` property which stands for the name for the runtime chunks.

```js title="rspack.config.mjs"
export default {
  optimization: {
    runtimeChunk: {
      // this will generate a chunk named `my-name.js`
      name: 'my-name',
    },
  },
};
```

:::tip
Imported modules are initialized for each runtime chunk separately, so if you include multiple entry chunks on a page, beware of this behavior. You will need to set `optimization.runtimeChunk` to `'single'` or use another configuration that ensures the page only contains one runtime instance.
:::

## optimization.sideEffects


- Type: `boolean | 'flag'`
- Default:[production mode](/config/mode#production) is`true`, [development mode](/config/mode#development) is`'flag'`


If you only want Rspack use the manual `sideEffects` flag via (`package.json` and `rules[].sideEffects`) and don't analyse source code:

```js title="rspack.config.mjs"
export default {
  optimization: {
    sideEffects: 'flag',
  },
};
```

`flag` tells Rspack to recognise the sideEffects flag in package.json or [rules\[\].sideEffects](/config/module-rules.md#rulessideeffects) to skip over modules which are flagged to contain no side effects when exports are not used.

`true` tells Rspack not only recognise the sideEffects flag, but also analyse modules which are not flagged explicitly, and determine if they have side effects or not.

```js title="rspack.config.mjs"
export default {
  optimization: {
    sideEffects: true,
  },
};
```

:::tip
`optimization.sideEffects` depends on [`optimization.providedExports`](#optimizationprovidedexports) to be enabled.
This dependency has a build time cost, but eliminating modules has positive impact on performance because of less code generation.
Effect of this optimization depends on your codebase, try it for possible performance wins.
:::

## optimization.splitChunks


- Type: `false | object`


Rspack supports splitting chunks with the `optimization.splitChunks` configuration item.

It is enabled by default for dynamically imported modules.

To turn it off, set it to `false`.

See available options for configuring this behavior in the [SplitChunksPlugin](/plugins/webpack/split-chunks-plugin.md) page.

## optimization.usedExports


- Type: `boolean | 'global'`
- Default:[production mode](/config/mode#production) is`true`, [development mode](/config/mode#development) is`false`


Tells Rspack to determine used exports for each module. This depends on `optimization.providedExports`.
Information collected by `optimization.usedExports` is used by other optimizations or code generation i.e.
Exports are not generated for unused exports, export names are mangled to single char identifiers when all usages are compatible. Dead code elimination in minimizers will benefit from this and can remove unused exports.

```js title="rspack.config.mjs"
export default {
  optimization: {
    usedExports: false,
  },
};
```

To opt-out from used exports analysis per runtime:

```js title="rspack.config.mjs"
export default {
  optimization: {
    usedExports: 'global',
  },
};
```