esbuild: The Ultra-Fast JavaScript Bundler Written in Go

In modern frontend projects, turning your source code into something the browser can understand and run efficiently requires a special tool called a bundler. A bundler combines dozens or hundreds of JavaScript modules, styles, and other resources into a handful of optimized files, resolves imports, and compresses the code when necessary. For many years Webpack dominated this space, but its sluggishness on large projects became a serious pain point for developers. This is exactly the moment esbuild appeared and completely reshaped the entire ecosystem's expectations about how fast a build can be.

What esbuild is and how it came about

esbuild is a tool for bundling and transforming JavaScript and TypeScript code, created by developer Evan Wallace. Its most important distinction is that it is written not in JavaScript or TypeScript, but in the Go programming language. This choice is far from accidental: Go compiles to machine code and offers lightweight concurrency mechanisms that let it fully utilize multi-core processors. As a result, esbuild runs tens and sometimes hundreds of times faster than traditional bundlers, and on large codebases this difference becomes especially noticeable.

Why esbuild is so fast

There are several fundamental reasons behind this speed. First, the Go language is turned into native machine code and avoids the overhead of tools that run on top of a JavaScript interpreter. Second, esbuild distributes work across processor cores in parallel, meaning that parsing files, transforming them, and generating the final code all happen simultaneously across multiple threads. Third, the tool uses memory carefully and avoids unnecessary copying of data it has already read. Together, all of this reduces to mere seconds the work that tools like Webpack or Babel would take minutes to complete.

What esbuild can do

esbuild is not limited to bundling modules alone. It combines several tasks into a single fast process: linking modules together, compressing code through minification, transpiling TypeScript and JSX syntax into plain JavaScript, and removing unused code via tree shaking. When processing TypeScript files, esbuild merely strips out the types and converts the syntax, but it does not perform type checking. For this reason, most teams check type errors with a separate tsc tool and use esbuild purely for fast code transformation.

Using esbuild from the command line

Installing and running esbuild is very simple. First you add it to your project, then on the command line you specify the entry file and the output options. In the example below, the application entry point is bundled, minified, and saved in a format intended for the browser.

npm install --save-dev esbuild

# Bundle, minify and output in a single command
npx esbuild src/app.ts \
  --bundle \
  --minify \
  --sourcemap \
  --target=es2020 \
  --outfile=dist/app.js

Here the bundle flag gathers all imports into one file, minify reduces the final size, and sourcemap lets you see the original source code in the browser. The target parameter determines which JavaScript version the result should be adapted to.

Using the JavaScript API

For more complex scenarios and automated build pipelines, esbuild offers a programmatic interface. Using the API, you gain full control over the build process, watch for changes in watch mode, or produce the result directly in memory.

import * as esbuild from 'esbuild'

await esbuild.build({
  entryPoints: ['src/app.ts'],
  bundle: true,
  minify: true,
  sourcemap: true,
  target: ['es2020'],
  outfile: 'dist/app.js',
  loader: { '.png': 'dataurl' },
})

console.log('Build finished')

The API version provides the same capabilities as the command line, but it can be flexibly embedded inside Node.js scripts. The loader parameter specifies how particular file types should be processed.

How Vite and other tools use esbuild

The greatest impact of esbuild is visible in how it works inside other popular tools. Vite, in development mode, uses esbuild specifically to pre-bundle dependencies and transpile TypeScript, which gives its server an almost instant startup. In a similar way, many other modern tools use esbuild as their internal engine. This means that if you work with Vite, you are already indirectly benefiting from the power of esbuild even without configuring it directly.

The limitations of esbuild

Speed comes at a price, and esbuild has its limitations too. First, its plugin ecosystem is noticeably smaller and less capable than Webpack's, so for some complex transformations you may not find a ready-made solution. Second, esbuild does not perform TypeScript type checking, which means you have to ensure type safety separately. In addition, some advanced optimization features, such as complex code-splitting scenarios, do not yet reach the level of more mature tools. For this reason, in very large projects with specific requirements, esbuild may not always be the only solution you need.

When to use esbuild directly

Using esbuild directly makes sense in the following cases: if you need an extremely fast build, if you are building a library or a small tool, or if you do not require complex configuration. For most applications, however, it is more convenient to use a higher-level tool like Vite, since it runs esbuild internally and provides additional conveniences. As the Sayt.uz team, we advise our clients to choose the right tool based on the scale and requirements of the project, because the correct choice noticeably increases development speed.