Open-source alternatives to Swc

UglifyJS is a tool for JavaScript code minification, AST manipulation, and source beautification. Its primary purpose is to reduce the file size of JavaScript source code by removing whitespace and shortening variable names to optimize frontend build assets. The project differentiates itself through its ability to programmatically analyze and transform code using abstract syntax trees. It performs constant folding analysis and conditional compilation to eliminate unreachable or redundant code, and it employs a multi-pass compression pipeline to maximize total file size reduction. The tool pr

Rollup is an ES module bundler and JavaScript module transpiler. It functions as a build tool that combines JavaScript modules into optimized files and converts modern JavaScript and JSX into various output formats for different runtime environments. The project is distinguished by its static-analysis tree shaking engine, which removes unused code and dead exports to minimize bundle size. It also acts as a code splitting orchestrator, partitioning modules into separate chunks to optimize network requests and load times. The tool provides a hook-based plugin system for extending build logic,

esbuild is a high-performance JavaScript bundler and transpiler designed to transform modern web assets into production-ready code. Built with a focus on speed, it utilizes a concurrent execution model to perform parsing, linking, and code generation across multiple CPU cores. The engine handles a wide range of tasks, including TypeScript compilation, JSX transformation, and CSS bundling, while maintaining a consistent build process across diverse environments. What distinguishes the project is its architecture, which leverages memory-mapped file processing and a single-pass transformation st

This project is a build orchestration engine and development toolkit designed for managing large-scale monorepos. It provides a unified workspace environment that maps project relationships and dependencies, enabling the system to perform intelligent impact analysis and execute only the tasks affected by specific code changes. The system distinguishes itself through a persistent daemon that monitors file changes for near-instant feedback and a content-addressable caching mechanism that stores task outputs to prevent redundant computation across local and remote environments. It further suppor

Poi is an extensible, zero-configuration module bundler and asset compiler for modern frontend development. It functions as a build system that transforms JavaScript, JSX, and CSS into browser-compatible files and combines them into single packages for web delivery. The tool is built around a plugin architecture that allows for custom extensions to the build pipeline and the addition of specialized asset processing logic. It employs a convention-based mapping system to automate build settings and target outputs without the need for manual configuration files. The project covers a broad range

Babel is a pluggable JavaScript compiler and transpiler that converts modern ECMAScript syntax into backwards-compatible versions of the language. It functions as an abstract syntax tree manipulator, parsing source code into a hierarchical structure to traverse and modify nodes for custom code transformations. The system utilizes a plugin-driven architecture to apply specific transformation rules and supports presets that bundle multiple plugins into named configuration groups. This enables the transformation of experimental syntax and the injection of non-global polyfills to ensure consisten

tsup is a build tool designed for the automated compilation and packaging of TypeScript and JavaScript source code into compatible module formats. It functions as a TypeScript library bundler that transforms source files into distributable assets with minimal manual configuration. The project provides a zero-config build pipeline that abstracts complex bundler settings into a simplified interface. It is an esbuild-based tool that produces simultaneous ESM and CommonJS output files from a single source tree to ensure broad environment compatibility. The tool covers high-performance transpilat

ts-jest is a TypeScript compilation tool and transformer that enables the Jest testing framework to execute tests written in TypeScript. It functions as a bridge that transpiles typed source code into executable JavaScript while maintaining the necessary integration for test runner execution. The project distinguishes itself by providing on-the-fly type diagnostics and pre-test type validation to identify structural errors before the execution phase. It includes a source map handler that links compiled JavaScript output back to the original TypeScript source lines to ensure accurate error sta

ts-node is a TypeScript execution engine and just-in-time transpiler for Node.js. It enables the direct execution of TypeScript files by converting them to JavaScript on the fly, removing the requirement for a manual pre-compilation build step. It also provides a TypeScript read-eval-print loop for evaluating expressions and testing code snippets in real time. The project integrates with the Node.js module system as a loader hook to resolve and load files using native import syntax. It features a pluggable compiler interface that allows the use of external transpilers to accelerate execution

This project is a unified toolchain for JavaScript and TypeScript development, providing a suite of specialized tools for bundling, parsing, linting, and formatting source code. The toolchain is implemented in Rust and utilizes a shared internal representation to allow multiple tools to operate on the same parsed source code. It employs a parallelized analysis pipeline and single-pass parsing with error recovery to process files across CPU cores. The suite covers several core capability areas, including static analysis for identifying programmatic errors, automated style standardization, and

Microbundle is a zero-configuration JavaScript module bundler designed to package small libraries and modules into optimized distribution files. It serves as a JavaScript library packager and TypeScript compiler, converting source code into compatible module formats for both browser and server-side runtimes. The tool functions as a bundle size optimizer by mangling object properties and analyzing bundle composition to reduce final file sizes. It also acts as a CSS module processor, converting style imports into external stylesheets or scoped modules to prevent global namespace collisions. It

This project is a command-line tool and build toolchain used to bootstrap React web applications. It serves as a project bootstrapper and single-page application scaffold, providing a pre-configured development environment, folder structure, and build pipeline. The toolchain integrates a frontend development server with live reloading and error overlays to accelerate the iterative coding process. It handles production asset bundling by minifying code and generating hashed assets for deployment, and it includes a configuration suite for generating the service workers and web manifests required

Rolldown is a high-performance JavaScript and TypeScript module bundler written in Rust. It functions as a fast module compiler that implements a Rollup-compatible API to ensure compatibility with existing workflows and plugins while specializing in ECMAScript Module formats. The project distinguishes itself by using a Rust-based core engine and lazy compilation to reduce the time spent resolving and transforming source code. It focuses on minimizing final delivery sizes through static analysis and tree-shaking to remove unused code. The toolset covers a broad range of build capabilities, in

Browserify is a build utility that enables the use of CommonJS module patterns within client-side JavaScript applications. It functions as a dependency manager and module bundler, tracing recursive import calls to package multiple source files and their dependencies into a single, optimized file for execution in web browser environments. The project distinguishes itself by providing a comprehensive compatibility layer that allows server-side code to run in the browser. It achieves this by injecting environment shims and replacing system-level globals with browser-compatible equivalents. Throu

Brunch is a frontend build tool and JavaScript asset bundler designed to automate the transformation of source code into production-ready assets. It functions as an incremental build system that monitors the filesystem for changes to rebuild only modified components, and it serves as a project scaffolding engine for initializing application structures via predefined skeletons and code boilerplates. The tool utilizes a plugin-based transformation pipeline to compile and optimize JavaScript and CSS files for browser delivery. It distinguishes itself through the use of multi-core build paralleli

This project is a Webpack build guide and a reference for implementing a JavaScript module bundler. It serves as a frontend build pipeline designed to resolve dependencies, package source files, and optimize assets for web browsers. The guide focuses on asset optimization and performance strategies. This includes implementing code splitting for asynchronous module loading, extracting shared dependencies to improve browser caching, and generating multiple entrypoints to reduce initial download sizes. The project covers a broad range of build-time capabilities, including modern JavaScript tran

oxc is a high-performance JavaScript toolchain developed in Rust for parsing, transforming, and analyzing JavaScript and TypeScript source code. It provides a set of core utilities including a parser that converts code into an abstract syntax tree, a linter for identifying problematic patterns, a formatter for standardizing visual style, and a minifier for reducing production file sizes. The project focuses on high-performance execution through a system design that utilizes single-pass parsing, zero-copy string slicing, and parallel worker processing to handle large codebases. It further opti

Sucrase is a high-speed transpilation tool that compiles modern JavaScript, TypeScript, JSX, and Flow to standard JavaScript for modern runtimes. It operates as a fast alternative to Babel, using a single-pass scanner and tokenizer that strips type annotations and applies only requested syntax transforms without building an AST or performing type checking. The tool differentiates itself through a zero-type-checking pipeline that omits type checking entirely, relying on the assumption that input code is already valid for the target runtime. It uses scanner-based tokenization and single-pass co

This repository is a collection of Webpack configuration examples and JavaScript module bundler demonstrations. It provides asset pipeline tutorials and frontend build tool examples focused on resolving dependencies and merging multiple modules into optimized browser files. The project demonstrates how to configure Webpack for transforming JavaScript assets, including the use of loaders and plugins to process JSX, CSS, and images into browser-ready formats. It includes practical examples of code splitting, minification, and environment variable injection. The covered capabilities include fro

UglifyJS2 is a suite of tools designed for parsing, beautifying, mangling, and minifying JavaScript code. It functions by converting source code into an abstract syntax tree to enable programmatic analysis and transformation, and it includes a dedicated generator for creating associated source maps. The project optimizes web production builds by compressing script logic and removing unreachable code. It utilizes name mangling to shorten variable and property names and implements a beautifier to reconstruct compressed scripts into a human-readable layout. The toolset covers broad capability a

Lebab is a JavaScript code modernization tool that converts older ES5 syntax into contemporary ES6 equivalents. It operates as a source-to-source transpiler, parsing code into an abstract syntax tree, applying structural transformations, and regenerating the output without intermediate representations or runtime dependencies. The tool distinguishes itself through a rule-driven pipeline of independent transformation rules, each targeting a specific ES6 feature like arrow functions, let/const, classes, or modules. It provides a programmatic API that accepts source code and an array of transform

ncc is a Node.js build tool and project bundler that compiles a project and its dependencies into a single JavaScript file. It functions as a single-file JavaScript bundler and TypeScript compiler, converting type-annotated source files into standard JavaScript compatible with the Node.js runtime. The tool focuses on serverless function optimization by reducing the number of files and dependencies in a deployment package to improve portability and cold start times. It automates the software release workflow by integrating the compilation and bundling process into programmatic scripts. The pr

This project is a web development boilerplate and starter kit providing a pre-configured foundation for creating high-performance, responsive websites. It functions as a development kit for building progressive web apps, incorporating a front-end build pipeline and responsive site templates. The kit distinguishes itself through a multi-device testing workflow that synchronizes clicks, scrolls, and form inputs across multiple browsers and devices in real-time. It also includes a dedicated setup for offline functionality using service workers and web manifests to enable native-like installation

react-slingshot is a JavaScript frontend boilerplate and starter kit designed to bootstrap React applications. It provides a pre-configured foundation that integrates React and Redux for state management, alongside routing and a unidirectional data flow. The project features an integrated build pipeline that handles Babel transpilation, Sass compilation, and module bundling. It includes a development environment with hot module replacement and source maps for rapid iteration, as well as production optimization tools for minifying assets and analyzing bundle size. The toolkit covers a broad s

Rspack is a high-performance web bundler written in Rust that packages JavaScript and TypeScript for web applications. It functions as an incremental build engine and a tree-shaking asset optimizer designed to reduce build times and minimize final bundle sizes for web delivery. The project is built for compatibility with the webpack ecosystem, implementing a compatible API that allows existing plugins and configurations to work without modification. This enables the integration of community loaders and plugins while leveraging a Rust-based compilation engine. The tool covers a broad range of

Vite is a frontend build toolchain that provides a unified development and production pipeline for modern web applications. It functions as a modular, environment-agnostic build engine that leverages native ES modules to serve source code directly to the browser, eliminating the need for expensive bundling during the development phase. By maintaining an environment-aware module graph, it supports concurrent development across client, server, and custom runtime environments. The project distinguishes itself through a high-performance development server that utilizes a hot module replacement pr

tModLoader is a modding framework and toolset designed for expanding game content and extending core game logic. It provides a polymorphic content API that allows for the creation of new items, NPCs, projectiles, and world assets through object-oriented inheritance. The project is distinguished by its advanced code modification capabilities, utilizing intermediate language bytecode patching and reflection-based private access to alter internal game behavior. It features a hot-reloading assembly runtime that enables developers to recompile and apply source code changes in real-time without res