# Minifier (/bundler/minifier)

<!-- agent-signals: reading_time_min: 13 · est_tokens: 5206 · updated: 2026-09-23 -->
Related: [Fullstack dev server](/bundler/fullstack.md), [Hot reloading](/bundler/hot-reloading.md), [HTML & static sites](/bundler/html-static.md), [Standalone HTML](/bundler/standalone-html.md), [CSS](/bundler/css.md), [Loaders](/bundler/loaders.md)

Bun includes a fast JavaScript and TypeScript minifier. Depending on the codebase, it can reduce bundle sizes by 80% or more. It can also make output code run faster. The minifier performs dozens of optimizations including constant folding, dead code elimination, and syntax transformations. Unlike other minifiers, Bun's minifier makes `bun build` run faster since there's less code to print.

## CLI Usage [#cli-usage]

### Enable all minification [#enable-all-minification]

Use the `--minify` flag to enable all minification modes:

```bash
bun build ./index.ts --minify --outfile=out.js
```

The `--minify` flag enables:

* Whitespace minification
* Syntax minification
* Identifier minification

### Production mode [#production-mode]

The `--production` flag automatically enables minification:

```bash
bun build ./index.ts --production --outfile=out.js
```

The `--production` flag also:

* Sets `process.env.NODE_ENV` to `production`
* Enables the production-mode JSX import & transform

### Granular control [#granular-control]

Enable specific minification modes individually:

```bash
# Only remove whitespace
bun build ./index.ts --minify-whitespace --outfile=out.js

# Only minify syntax
bun build ./index.ts --minify-syntax --outfile=out.js

# Only minify identifiers
bun build ./index.ts --minify-identifiers --outfile=out.js

# Combine specific modes
bun build ./index.ts --minify-whitespace --minify-syntax --outfile=out.js
```

## JavaScript API [#javascript-api]

When using Bun's bundler programmatically, configure minification through the `minify` option:

```ts
await Bun.build({
  entrypoints: ["./index.ts"],
  outdir: "./out",
  minify: true, // Enable all minification modes
});
```

For granular control, pass an object:

```ts
await Bun.build({
  entrypoints: ["./index.ts"],
  outdir: "./out",
  minify: {
    whitespace: true,
    syntax: true,
    identifiers: true,
  },
});
```

## Minification Modes [#minification-modes]

Bun's minifier has three independent modes that you can enable separately or together.

### Whitespace minification (`--minify-whitespace`) [#whitespace-minification---minify-whitespace]

Removes all unnecessary whitespace, newlines, and formatting from the output.

### Syntax minification (`--minify-syntax`) [#syntax-minification---minify-syntax]

Rewrites JavaScript syntax to shorter equivalent forms and performs constant folding, dead code elimination, and other optimizations.

### Identifier minification (`--minify-identifiers`) [#identifier-minification---minify-identifiers]

Renames local variables and function names to shorter identifiers using frequency-based optimization.

## All Transformations [#all-transformations]

### Boolean literal shortening [#boolean-literal-shortening]

**Mode:** `--minify-syntax`

Converts boolean literals to shorter expressions.

```ts title="Input"
true
false
```

```js title="Output"
!0
!1
```

### Boolean algebra optimizations [#boolean-algebra-optimizations]

**Mode:** `--minify-syntax`

Simplifies boolean expressions using logical rules.

```ts title="Input"
if (!!x) y;
if (x && true) y;
if (x || false) y;
!true
!false
```

```js title="Output"
if(x)y;
if(x)y;
if(x)y;
!1
!0
```

### Undefined shortening [#undefined-shortening]

**Mode:** `--minify-syntax`

Replaces `undefined` with shorter equivalent.

```ts title="Input"
undefined
let x = undefined;
```

```js title="Output"
void 0
let x=void 0;
```

### Undefined equality optimization [#undefined-equality-optimization]

**Mode:** `--minify-syntax`

Optimizes loose equality checks with undefined.

```ts title="Input"
x == undefined
x != undefined
```

```js title="Output"
x == null
x != null
```

### Infinity shortening [#infinity-shortening]

**Mode:** `--minify-syntax`

Converts Infinity to mathematical expressions.

```ts title="Input"
Infinity
-Infinity
```

```js title="Output"
1/0
-1/0
```

### Typeof optimizations [#typeof-optimizations]

**Mode:** `--minify-syntax`

Optimizes typeof comparisons and evaluates constant typeof expressions.

```ts title="Input"
typeof x === 'undefined'
typeof x !== 'undefined'
typeof require
typeof null
typeof true
typeof 123
typeof "str"
typeof 123n
```

```js title="Output"
typeof x>'u'
typeof x<'u'
"function"
"object"
"boolean"
"number"
"string"
"bigint"
```

### Number formatting [#number-formatting]

**Mode:** `--minify-syntax`

Formats numbers in the most compact representation.

```ts title="Input"
10000
100000
1000000
1.0
-42.0
```

```js title="Output"
1e4
1e5
1e6
1
-42
```

### Arithmetic constant folding [#arithmetic-constant-folding]

**Mode:** `--minify-syntax`

Evaluates arithmetic operations at compile time.

```ts title="Input"
1 + 2
10 - 5
3 * 4
10 / 2
10 % 3
2 ** 3
```

```js title="Output"
3
5
12
5
1
8
```

### Bitwise constant folding [#bitwise-constant-folding]

**Mode:** `--minify-syntax`

Evaluates bitwise operations at compile time.

```ts title="Input"
5 & 3
5 | 3
5 ^ 3
8 << 2
32 >> 2
~5
```

```js title="Output"
1
7
6
32
8
-6
```

### String concatenation [#string-concatenation]

**Mode:** `--minify-syntax`

Combines string literals at compile time.

```ts title="Input"
"a" + "b"
"x" + 123
"foo" + "bar" + "baz"
```

```js title="Output"
"ab"
"x123"
"foobarbaz"
```

### String indexing [#string-indexing]

**Mode:** `--minify-syntax`

Evaluates string character access at compile time.

```ts title="Input"
"foo"[2]
"hello"[0]
```

```js title="Output"
"o"
"h"
```

### Template literal folding [#template-literal-folding]

**Mode:** `--minify-syntax`

Evaluates template literals with constant expressions.

```ts title="Input"
`a${123}b`
`result: ${5 + 10}`
```

```js title="Output"
"a123b"
"result: 15"
```

### Template literal to string conversion [#template-literal-to-string-conversion]

**Mode:** `--minify-syntax`

Converts template literals with no substitutions to regular strings.

```ts title="Input"
`Hello World`
`Line 1
Line 2`
```

```js title="Output"
"Hello World"
"Line 1\nLine 2"
```

### String quote optimization [#string-quote-optimization]

**Mode:** `--minify-syntax`

Chooses the optimal quote character to minimize escapes.

```ts title="Input"
"It's a string"
'He said "hello"'
`Simple string`
```

```js title="Output"
"It's a string"
'He said "hello"'
"Simple string"
```

### Array spread inlining [#array-spread-inlining]

**Mode:** `--minify-syntax`

Inlines array spread operations with constant arrays.

```ts title="Input"
[1, ...[2, 3], 4]
[...[a, b]]
```

```js title="Output"
[1,2,3,4]
[a,b]
```

### Array indexing [#array-indexing]

**Mode:** `--minify-syntax`

Evaluates constant array access at compile time.

```ts title="Input"
[x][0]
['a', 'b', 'c'][1]
['a', , 'c'][1]
```

```js title="Output"
x
'b'
void 0
```

### Property access optimization [#property-access-optimization]

**Mode:** `--minify-syntax`

Converts bracket notation to dot notation when possible.

```ts title="Input"
obj["property"]
obj["validName"]
obj["123"]
obj["invalid-name"]
```

```js title="Output"
obj.property
obj.validName
obj["123"]
obj["invalid-name"]
```

### Comparison folding [#comparison-folding]

**Mode:** `--minify-syntax`

Evaluates constant comparisons at compile time.

```ts title="Input"
3 < 5
5 > 3
3 <= 3
5 >= 6
"a" < "b"
```

```js title="Output"
!0
!0
!0
!1
!0
```

### Logical operation folding [#logical-operation-folding]

**Mode:** `--minify-syntax`

Simplifies logical operations with constant values.

```ts title="Input"
true && x
false && x
true || x
false || x
```

```js title="Output"
x
!1
!0
x
```

### Nullish coalescing folding [#nullish-coalescing-folding]

**Mode:** `--minify-syntax`

Evaluates nullish coalescing with known values.

```ts title="Input"
null ?? x
undefined ?? x
42 ?? x
```

```js title="Output"
x
x
42
```

### Comma expression simplification [#comma-expression-simplification]

**Mode:** `--minify-syntax`

Removes side-effect-free expressions from comma sequences.

```ts title="Input"
(0, x)
(123, "str", x)
```

```js title="Output"
x
x
```

### Ternary conditional folding [#ternary-conditional-folding]

**Mode:** `--minify-syntax`

Evaluates conditional expressions with constant conditions.

```ts title="Input"
true ? a : b
false ? a : b
x ? true : false
x ? false : true
```

```js title="Output"
a
b
x ? !0 : !1
x ? !1 : !0
```

### Unary expression folding [#unary-expression-folding]

**Mode:** `--minify-syntax`

Simplifies unary operations.

```ts title="Input"
+123
+"123"
-(-x)
~~x
!!x
```

```js title="Output"
123
123
- -x
~~x
!!x
```

### Double negation removal [#double-negation-removal]

**Mode:** `--minify-syntax`

Removes unnecessary double negations.

```ts title="Input"
if (!!x) y;
!!!x
```

```js title="Output"
if(x)y;
!x
```

### If statement optimization [#if-statement-optimization]

**Mode:** `--minify-syntax`

Optimizes if statements with constant conditions.

```ts title="Input"
if (true) x;
if (false) x;
if (x) { a; }
if (x) {} else y;
```

```js title="Output"
x;
// removed
if(x)a;
if(!x)y;
```

### Dead code elimination [#dead-code-elimination]

**Mode:** `--minify-syntax`

Removes unreachable code and code without side effects.

```ts title="Input"
if (false) {
  unreachable();
}
function foo() {
  return x;
  deadCode();
}
```

```js title="Output"
function foo(){return x}
```

### Unreachable branch removal [#unreachable-branch-removal]

**Mode:** `--minify-syntax`

Removes branches that can never execute.

```ts title="Input"
while (false) {
  neverRuns();
}
```

```js title="Output"
// removed entirely
```

### Empty block removal [#empty-block-removal]

**Mode:** `--minify-syntax`

Removes empty blocks and unnecessary braces.

```ts title="Input"
{ }
if (x) { }
```

```js title="Output"
;
// removed
```

### Single statement block unwrapping [#single-statement-block-unwrapping]

**Mode:** `--minify-syntax`

Removes unnecessary braces around single statements.

```ts title="Input"
if (condition) {
  doSomething();
}
```

```js title="Output"
if(condition)doSomething();
```

### TypeScript enum inlining [#typescript-enum-inlining]

**Mode:** `--minify-syntax`

Inlines TypeScript enum values at compile time.

```ts title="Input"
enum Color { Red, Green, Blue }
const x = Color.Red;
```

```js title="Output"
const x=0;
```

### Pure annotation support [#pure-annotation-support]

**Mode:** Always active

Respects `/*@__PURE__*/` annotations for tree shaking (removing unused code).

```ts title="Input"
const x = /*@__PURE__*/ expensive();
// If x is unused...
```

```js title="Output"
// removed entirely
```

### Identifier renaming [#identifier-renaming]

**Mode:** `--minify-identifiers`

Renames local variables to shorter names based on usage frequency.

```ts title="Input"
function calculateSum(firstNumber, secondNumber) {
  const result = firstNumber + secondNumber;
  return result;
}
```

```js title="Output"
function n(t,u){const c=t+u;return c}
```

**Naming strategy:**

* Most frequently used identifiers get the shortest names; Bun orders the alphabet by how often each character appears in the source, so the first names are usually letters like t, e and n rather than a, b, c
* Single characters: a-z, A-Z and `_` (53 names; `$` alone is reserved)
* Two characters: the second character can also be a digit (up to 3,456 names)
* Three characters and beyond as needed

**Preserved identifiers:**

* JavaScript keywords and reserved words
* Global identifiers
* Named exports (to maintain API)
* CommonJS names: `exports`, `module`

### Whitespace removal [#whitespace-removal]

**Mode:** `--minify-whitespace`

Removes all unnecessary whitespace.

```ts title="Input"
function add(a, b) {
    return a + b;
}
let x = 10;
```

```js title="Output"
function add(a,b){return a+b}let x=10;
```

### Semicolon optimization [#semicolon-optimization]

**Mode:** `--minify-whitespace`

Inserts semicolons only when necessary.

```ts title="Input"
let a = 1;
let b = 2;
return a + b;
```

```js title="Output"
let a=1;let b=2;return a+b
```

### Operator spacing removal [#operator-spacing-removal]

**Mode:** `--minify-whitespace`

Removes spaces around operators.

```ts title="Input"
a + b
x = y * z
foo && bar || baz
```

```js title="Output"
a+b
x=y*z
foo&&bar||baz
```

### Comment removal [#comment-removal]

**Mode:** `--minify-whitespace`

Removes comments except important license comments.

```ts title="Input"
// This comment is removed
/* So is this */
/*! But this license comment is kept */
function test() { /* inline comment */ }
```

```js title="Output"
/*! But this license comment is kept */
function test(){}
```

### Object and array formatting [#object-and-array-formatting]

**Mode:** `--minify-whitespace`

Removes whitespace in object and array literals.

```ts title="Input"
const obj = {
    name: "John",
    age: 30
};
const arr = [1, 2, 3];
```

```js title="Output"
const obj={name:"John",age:30};const arr=[1,2,3];
```

### Control flow formatting [#control-flow-formatting]

**Mode:** `--minify-whitespace`

Removes whitespace in control structures.

```ts title="Input"
if (condition) {
    doSomething();
}
for (let i = 0; i < 10; i++) {
    console.log(i);
}
```

```js title="Output"
if(condition)doSomething();for(let i=0;i<10;i++)console.log(i);
```

### Function formatting [#function-formatting]

**Mode:** `--minify-whitespace`

Removes whitespace in function declarations.

```ts title="Input"
function myFunction(param1, param2) {
    return param1 + param2;
}
const arrow = (a, b) => a + b;
```

```js title="Output"
function myFunction(param1,param2){return param1+param2}const arrow=(a,b)=>a+b;
```

### Parentheses minimization [#parentheses-minimization]

**Mode:** Always active

Only adds parentheses when necessary for operator precedence.

```ts title="Input"
(a + b) * c
a + (b * c)
((x))
```

```js title="Output"
(a+b)*c
a+b*c
x
```

### Template literal value folding [#template-literal-value-folding]

**Mode:** `--minify-syntax`

Converts non-string interpolated values to strings and folds them into the template.

```ts title="Input"
`hello ${123}`
`value: ${true}`
`result: ${null}`
`status: ${undefined}`
`big: ${10n}`
```

```js title="Output"
"hello 123"
"value: true"
"result: null"
"status: undefined"
"big: 10"
```

### String length constant folding [#string-length-constant-folding]

**Mode:** `--minify-syntax`

Evaluates `.length` property on string literals at compile time.

```ts title="Input"
"hello world".length
"test".length
```

```js title="Output"
11
4
```

### Constructor call simplification [#constructor-call-simplification]

**Mode:** `--minify-syntax`

Simplifies constructor calls for built-in types.

```ts title="Input"
new Object()
new Object(null)
new Object({a: 1})
new Array()
new Array(x, y)
```

```js title="Output"
{}
{}
{a:1}
[]
[x,y]
```

### Single property object inlining [#single-property-object-inlining]

**Mode:** `--minify-syntax`

Inlines property access for objects with a single property.

```ts title="Input"
({fn: () => console.log('hi')}).fn
```

```js title="Output"
() => console.log('hi')
```

### String charCodeAt constant folding [#string-charcodeat-constant-folding]

**Mode:** Always active

Evaluates `charCodeAt()` on string literals for ASCII characters.

```ts title="Input"
"hello".charCodeAt(1)
"A".charCodeAt(0)
```

```js title="Output"
101
65
```

### Void 0 equality to null equality [#void-0-equality-to-null-equality]

**Mode:** `--minify-syntax`

Converts loose equality checks with `void 0` to `null` since they're equivalent.

```ts title="Input"
x == void 0
x != void 0
```

```js title="Output"
x == null
x != null
```

### Negation operator optimization [#negation-operator-optimization]

**Mode:** `--minify-syntax`

Moves negation operator through comma expressions.

```ts title="Input"
-(a, b)
-(x, y, z)
```

```js title="Output"
a,-b
x,y,-z
```

### Import.meta property inlining [#importmeta-property-inlining]

**Mode:** Bundle mode

Inlines `import.meta` properties at build time when values are known.

```ts title="Input"
import.meta.dir
import.meta.file
import.meta.path
import.meta.url
```

```js title="Output"
"/path/to/directory"
"filename.js"
"/full/path/to/file.js"
"file:///full/path/to/file.js"
```

### Variable declaration merging [#variable-declaration-merging]

**Mode:** `--minify-syntax`

Merges adjacent variable declarations of the same type.

```ts title="Input"
let a = 1;
let b = 2;
const c = 3;
const d = 4;
```

```js title="Output"
let a=1,b=2;
const c=3,d=4;
```

### Expression statement merging [#expression-statement-merging]

**Mode:** `--minify-syntax`

Merges adjacent expression statements using comma operator.

```ts title="Input"
console.log(1);
console.log(2);
console.log(3);
```

```js title="Output"
console.log(1),console.log(2),console.log(3);
```

### Return statement merging [#return-statement-merging]

**Mode:** `--minify-syntax`

Merges expressions before return with comma operator.

```ts title="Input"
console.log(x);
return y;
```

```js title="Output"
return console.log(x),y;
```

### Throw statement merging [#throw-statement-merging]

**Mode:** `--minify-syntax`

Merges expressions before throw with comma operator.

```ts title="Input"
console.log(x);
throw new Error();
```

```js title="Output"
throw(console.log(x),new Error());
```

### TypeScript enum cross-module inlining [#typescript-enum-cross-module-inlining]

**Mode:** `--minify-syntax` (bundle mode)

Inlines enum values across module boundaries.

```ts title="Input"
// lib.ts
export enum Color { Red, Green, Blue }

// Input (main.ts)
import { Color } from './lib';
const x = Color.Red;
```

```js title="Output"
const x=0;
```

### Computed property enum inlining [#computed-property-enum-inlining]

**Mode:** `--minify-syntax`

Inlines enum values used as computed object properties.

```ts title="Input"
enum Keys { FOO = 'foo' }
const obj = { [Keys.FOO]: value }
```

```js title="Output"
const obj={foo:value}
```

### Arrow function body shortening [#arrow-function-body-shortening]

**Mode:** `--minify-syntax`

Uses expression body syntax when an arrow function only returns a value.

```ts title="Input"
() => { return x; }
(a) => { return a + 1; }
```

```js title="Output"
() => x
a => a + 1
```

### Object property shorthand [#object-property-shorthand]

**Mode:** Always active

Uses shorthand syntax when property name and value identifier match.

```ts title="Input"
{ x: x, y: y }
{ name: name, age: age }
```

```js title="Output"
{ x, y }
{ name, age }
```

### Drop debugger statements [#drop-debugger-statements]

**Mode:** `--drop=debugger`

Removes `debugger` statements from code.

```ts title="Input"
function test() {
  debugger;
  return x;
}
```

```js title="Output"
function test(){return x}
```

### Drop console calls [#drop-console-calls]

**Mode:** `--drop=console`

Removes all `console.*` method calls from code.

```ts title="Input"
console.log("debug");
console.warn("warning");
x = console.error("error");
```

```js title="Output"
void 0;
void 0;
x=void 0;
```

### Drop custom function calls [#drop-custom-function-calls]

**Mode:** `--drop=<name>`

Removes calls to specified global functions and their methods.

```ts title="Input"
assert(condition);
assert.equal(a, b);
```

```js --drop=assert title="Output with"
void 0;
void 0;
```

## Keep Names [#keep-names]

To keep original function and class names for debugging while minifying identifiers, use the `--keep-names` flag:

```bash
bun build ./index.ts --minify --keep-names --outfile=out.js
```

Or in the JavaScript API:

```ts
await Bun.build({
  entrypoints: ["./index.ts"],
  outdir: "./out",
  minify: {
    identifiers: true,
    keepNames: true,
  },
});
```

`--keep-names` preserves the `.name` property on functions and classes while still minifying the identifiers themselves.

## Combined Example [#combined-example]

Using all three minification modes together:

```ts title="input.ts (176 bytes)"
const myVariable = 42;

const myFunction = () => {
  const isValid = true;
  const result = undefined;
  return isValid ? myVariable : result;
};

const output = myFunction();
```

```js title="output.js"
// Output with --minify (20 bytes, 89% reduction)
var t=()=>42,e=t();
```

## When to Use Minification [#when-to-use-minification]

**Use `--minify` for:**

* Production bundles
* Reducing CDN bandwidth costs
* Improving page load times

**Use individual modes for:**

* **`--minify-whitespace`:** Size reduction without semantic changes
* **`--minify-syntax`:** Smaller output while keeping readable identifiers for debugging
* **`--minify-identifiers`:** Maximum size reduction (combine with `--keep-names` for better stack traces)

**Avoid minification for:**

* Development builds (harder to debug)
* When you need readable error messages
* Libraries where consumers may read the source