Build Tools

esbuild39.9k★

Esbuild does it 10-100x faster than Webpack. Written in Go, compiled to native code, parallelized from the ground up. A bundle that takes Webpack 30 seconds takes esbuild 300 milliseconds. Those aren't marketing numbers. That's what you'll actually see. MIT license, created by Evan Wallace (co-founder of Figma). Handles JS, TypeScript, JSX, CSS, and JSON. Tree-shaking, minification, source maps, code splitting, the core bundling features are all there. Vite uses esbuild internally for dependency pre-bundling. Fully free. It's a CLI tool and Go library. No paid tier, no hosted version. Solo to enterprise: free across the board. The only question is whether you use it directly or through Vite. The catch is what esbuild deliberately doesn't do. No HMR (hot module replacement) for dev servers. No native HTML entry points. Limited plugin API compared to Webpack or Rollup. Evan Wallace has been explicit: esbuild is a bundler, not a framework. If you need a full dev server experience, use Vite (which uses esbuild under the hood). If you need a fast bundler for production builds, CI pipelines, or as a library inside other tools, esbuild is the engine to use.

llvm-project38.2k★

LLVM is the compiler infrastructure that most of the modern toolchain runs on, whether you realize it or not. Clang (C/C++), Flang (Fortran), LLDB (debugger), LLD (linker), libc++, and more, all in one monorepo. Apple, Google, and most major tech companies depend on it. The entire thing is free under Apache 2.0. Self-hosting LLVM is not really the right framing because this is not a service. You build it from source or use your OS package manager. The real question is whether you should use Clang over GCC. For most C/C++ work, Clang gives you better error messages, faster compile times, and tighter integration with modern tooling (LSP, sanitizers, static analysis). GCC still wins in some edge cases around Fortran and certain embedded targets. Solo developers and small teams should just use whatever Clang version ships with their OS. Large teams doing compiler work or building language tooling will want to build from source and target specific LLVM passes. If you are writing a new programming language, LLVM as a backend saves you years of work. The catch: the codebase is massive. Building from source takes serious hardware and time. Contributing requires deep compiler knowledge, and the learning curve is one of the steepest in open source.

Just33.5k★

You write a `justfile` with named recipes, and `just build` or `just deploy` runs them. That's it. CC0 license (public domain), Rust. The syntax is intentionally similar to Make but without Make's tab-sensitivity and implicit rules. Variables, arguments, conditional logic, and shell selection (bash, sh, PowerShell, Python) are built in. Cross-platform. Fully free. Single binary, no paid tier, no cloud service. Public domain license. Use it however you want. Every developer at every team size benefits. Drop a `justfile` in your repo, document your common commands, and new team members can `just --list` to see everything available. Onboarding time drops immediately. The catch: Just is only a command runner. It doesn't understand file dependencies. If you need "rebuild only when source files changed," that's Make's strength and Just explicitly doesn't do it. If your project needs real dependency-based builds, Just is the wrong tool. Use it for orchestrating commands, not building software.

SWC33.4k★

SWC does the same work as Babel, 20-70x faster, because it's written in Rust instead of JavaScript. It replaces Babel for transpilation and Terser for minification. Apache 2.0, used by Next.js, Deno, and Parcel. When Vercel adopted SWC as Next.js's default compiler, build times dropped dramatically for every Next.js project. That's the real-world validation. Fully free. CLI tool and JavaScript API, no paid tier. The catch: SWC's Babel plugin compatibility is incomplete. If your project relies on specific Babel plugins (especially ones that transform code in unusual ways), you might hit gaps. The bundler (swcpack) is still experimental. Most teams use SWC for transpilation only and pair it with a separate bundler. And when something goes wrong, debugging is harder than Babel because the actual processing happens in Rust, not JavaScript. For most projects the speed gain is worth it, but test your build thoroughly before migrating from Babel.

Turborepo30.4k★

Turborepo makes monorepo builds fast by caching everything and only rebuilding what changed. Instead of running tests and builds for your entire repo on every commit, Turborepo figures out which packages were affected and skips the rest. Fully free under MIT. The CLI, task runner, local caching, and all core features cost nothing. Vercel offers Remote Caching (sharing build cache across your team's machines and CI) through their platform, free on the Hobby plan, included with Vercel Pro/Enterprise. There's nothing to host. It's a CLI tool in your repo. `npx turbo init` in an existing monorepo and you're started. Configuration is a single `turbo.json` file. The learning curve is gentle if you already understand your dependency graph. Solo developers: the local caching alone saves time on rebuilds. Small teams: remote caching is where the magic happens. One person builds, everyone benefits. Large teams: Turborepo or Nx. Those are your two real options. The catch: Turborepo is simpler than Nx but also less powerful. If you need code generation, dependency graph visualization, or affected-project detection beyond builds, Nx does more. Turborepo does less, but what it does, it does with almost zero config.

Nx28.7k★

Nx is the power tool that makes monorepos with multiple apps and libraries manageable. It understands your entire dependency graph (which projects depend on which) and uses that to run only what's affected by your changes. Builds, tests, linting: Nx caches everything and skips what hasn't changed. The core Nx CLI and all open source plugins are free under MIT. Nx Cloud (remote caching and distributed task execution) has a free tier and paid plans starting at $300/mo for Pro. Nx installs as an npm package. No hosting required. It reads your repo structure and generates a project graph automatically. Setup takes 30 minutes for an existing repo. The VS Code extension is useful. It visualizes your dependency graph. Solo developers: Nx is valuable even on smaller repos. The caching saves time immediately. Small teams: the free Nx Cloud tier shares cache across your team. Growing teams: this is where Nx shines. Affected detection and distributed execution cut CI from hours to minutes. The catch: Nx is more complex than Turborepo. More features means more configuration, more concepts to learn, more opinions about how your repo should be structured. If all you need is cached builds, Turborepo is simpler. If you need code generation, project constraints, and module boundaries, Nx is the answer.

Rollup26.3k★

Rollup bundles JavaScript libraries into clean, tree-shakeable output across ESM, CommonJS, and UMD formats. It was built specifically for library authors who want the smallest possible output with dead code eliminated. used internally by Vite (which uses Rollup for production builds). Rollup pioneered tree-shaking in JavaScript, analyzing your import/export graph and stripping out unused code. The result is smaller bundles than webpack for library use cases. Fully free. MIT-ish license (check repo for specifics). No paid tier, no cloud service. It's a CLI tool and JavaScript API. The catch: Rollup is for libraries, not applications. If you're building a web app, use Vite (which uses Rollup under the hood anyway) or webpack. Rollup's plugin ecosystem is good but smaller than webpack's. And for raw speed, SWC and esbuild are significantly faster; Rollup prioritizes output quality over build speed. If your library builds take seconds, that's fine. If they take minutes, look at the Rust/Go-based alternatives.

Biome24.6k★

Biome replaces ESLint and Prettier in a single tool that's 20-35x faster, ending the configuration fights and slow lint runs. It formats and lints your JavaScript, TypeScript, JSX, JSON, and CSS in one pass. Written in Rust, so speed isn't a marketing claim. It's the whole point. Everything is free for individual and team use. There's an 'enterprise' page on their site, but the core tool is fully open source under Apache 2.0. No features are gated. You install it, configure your rules, and run it. The catch: Biome's rule set is still catching up to ESLint's plugin ecosystem. If you rely on specialized ESLint plugins (React hooks rules, accessibility linting, import sorting with custom groups), check that Biome covers your specific rules before migrating. The gap is closing fast, but it's not 1:1 yet.

OXC21.1k★

OXC wants to replace your JavaScript parser, linter, formatter, and minifier, and do all of it 10-100x faster. It's a collection of JS tooling rewritten in Rust with performance as the obsession. The linter alone runs ~50-100x faster than ESLint on real codebases. Everything is free under MIT. No paid tier, no cloud service, no enterprise upsell. This is pure open source tooling backed by VoidZero (the company behind Vite). There's nothing to self-host: it's developer tooling you install as a dependency. `npm install oxlint` and you're running. Zero configuration works out of the box, though you can customize rules. The parser is used internally by other tools (Rspack, Rolldown) so you're probably already benefiting from it indirectly. Solo developers: switch your linter to oxlint today. The speed difference is immediately noticeable. Small to large teams: the CI time savings alone justify the switch: minutes off every pipeline run. The formatter is newer and less battle-tested than Prettier, but the linter is solid. The catch: OXC isn't ESLint-compatible. You can't use your existing ESLint plugins. The oxlint rules cover most common cases but the plugin ecosystem is nowhere close. If you rely on niche ESLint plugins, you'll run both for a while.

GoReleaser15.8k★

One command, and your release ships everywhere. MIT license, Go. Builds for Linux, macOS, Windows, ARM, AMD64 in parallel. Creates GitHub/GitLab releases with changelogs, publishes to Homebrew taps, Docker registries, Snapcraft, Scoop, and APT/RPM repositories. Integrates with CI (GitHub Actions, GitLab CI) for fully automated releases. Free tier (GoReleaser OSS): handles most release workflows: cross-compilation, GitHub releases, Docker images, Homebrew. Covers 90% of use cases. Pro: $11/month (billed annually at $132/year). Adds: custom publishers, monorepo support, Nix packages, and priority support. Enterprise: custom pricing for larger organizations. Solo Go developers: the free version is everything you need. Small teams: free unless you're in a monorepo. Medium teams: $11/mo Pro when you need custom publishers or monorepo support. The catch: it's Go-specific. If you release in multiple languages, you need separate release tooling for each. And the config file (`.goreleaser.yaml`) gets complex fast when you're targeting many platforms with different build flags. The docs are good but the config surface area is large.

Task15.5k★

A modern replacement for Make. If you have a project with build commands, test scripts, deploy steps, or any repeatable tasks and you're tired of writing Makefiles with their tab-sensitivity and cryptic syntax, Task uses a simple YAML file instead. Define your tasks in a `Taskfile.yml`, run them with `task build`, `task test`, `task deploy`. It handles dependencies between tasks, runs things in parallel, watches files for changes, and works on Linux, Mac, and Windows without any compatibility headaches. Written in Go, ships as a single binary with zero dependencies. Completely free. MIT licensed. No paid tier. Install via brew, go install, npm, or download the binary. The catch: it's "just" a task runner. If you need a full build system with caching, remote execution, and dependency graph optimization, look at Turborepo, Bazel, or Nx. Task doesn't cache outputs; it re-runs every time unless you set up fingerprinting manually. For most projects, that doesn't matter. But for large monorepos with 30-minute builds, you need something smarter. For everything else, Task is cleaner than Make and simpler than everything else.