Open-source alternatives to Minify

This project is a JavaScript optimizer, minifier, module bundler, transpiler, and static analysis tool. It provides a compilation pipeline designed to shrink file sizes and improve runtime performance. The system utilizes a multi-pass compilation process to perform dead code elimination, global name mangling, and static type inference. It identifies unreachable functions and unused variables to reduce the final output size and detects potential runtime errors without executing the code. The tool manages assets through dependency resolution, code chunking, and bundle management. It ensures co

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

This project is a Babel plugin that enables the use of JSX syntax within Vue 2 applications. It functions as a build-time transpilation tool, converting declarative JSX into standard JavaScript render functions that are compatible with the framework's component system. The plugin bridges the gap between JSX and the framework by mapping standard template directives, such as event handling and model binding, directly to JSX attributes. It also provides automatic injection of the component instance context, allowing developers to access reactive properties and lifecycle methods directly within t

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

Terser is a JavaScript minifier and compressor designed to reduce file size through whitespace removal, symbol mangling, and logic optimization for ES6+. It functions as a toolkit for minification, a code mangler for shortening variable and property names, and a dead code eliminator that evaluates constant expressions to remove unreachable logic. The project operates as an AST toolkit that parses JavaScript source into SpiderMonkey AST format for structural analysis. It generates source maps to link compressed production code back to the original source, ensuring that minified bundles remain

Closure Compiler is a JavaScript build utility designed to transform, optimize, and validate source code for production environments. It functions as a minifier and transpiler, converting modern ECMAScript syntax into older, widely compatible versions to ensure reliable execution across diverse browsers. The tool distinguishes itself through a multi-pass optimization pipeline that performs complex refactoring, such as constant folding, function inlining, and variable renaming. It utilizes a static type inference engine to detect potential runtime errors and enforce type safety without requiri

Prepack is a build-time code evaluator and JavaScript bundle optimizer. It functions as a static analysis compiler that pre-evaluates static code and precalculates function results and global assignments during the build phase to accelerate startup times and reduce bundle size. The project specifically targets JSX optimization by processing syntax and node serialization to improve user interface rendering efficiency. It utilizes a partial evaluation engine and static execution analysis to replace runtime computations with precalculated constants. The tool covers a range of capabilities inclu

Clean-CSS is a Node.js CSS optimizer and minifier designed to reduce stylesheet file sizes and improve web performance. It functions as a CSS post-processor that removes unnecessary whitespace, comments, and redundant properties from stylesheets. The project utilizes an abstract syntax tree for parsing and a multi-pass optimization pipeline to restructure rules and simplify properties. It features a plugin interface for custom style transformations and provides compatibility-aware minification to ensure styles remain functional across specific legacy browser versions. Additional capabilities

Myth is a CSS build tool and preprocessor that transforms modern styling specifications and future syntax into compatible code for current web browsers. It functions as a polyfill tool, converting advanced features into standard CSS to ensure consistent cross-browser rendering. The project provides automated vendor prefixing based on browser support data and resolves CSS variables into static values for legacy browser compatibility. It also handles the transpilation of custom media query aliases and the manipulation of advanced color functions into standard formats. The toolset includes a co

Acorn is a JavaScript parser that converts source text into a structured abstract syntax tree. It follows the ESTree specification to produce a standardized JSON tree format, enabling consistent analysis of code structure and language versions. The project features a plugin-based grammar extension system that allows the base parser to be extended with custom rules for experimental or non-standard language features. It also includes syntax error recovery, which inserts placeholder nodes into the tree when encountering invalid code to allow parsing to continue. The toolset covers static analys

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

Regenerator is a JavaScript generator transpiler and build-time code processor. It converts ECMAScript generator functions and asynchronous iteration into ES5 compatible state machines to ensure modern control flow works in legacy runtimes. The project functions as an ES5 compatibility transformer that rewrites advanced asynchronous patterns into standard JavaScript. It includes a runtime polyfill helper library to manage the iteration protocol and coordinate state transitions for the transpiled code. The tool provides capabilities for language transformation and asynchronous workflow polyfi

ts-migrate is an automated migration tool designed to transform JavaScript source code into compiling TypeScript files. It functions as a code migration framework that uses abstract syntax trees to perform large-scale refactoring and structural changes across a project. The tool provides a customizable framework for defining plugin-based transformation rules, allowing for the automation of specific code changes. It includes specialized engines for converting JSDoc type definitions into native TypeScript annotations and a utility for suppressing compiler errors by inserting type assertions or

This project is a technical handbook and tutorial guide for the Babel compiler. It serves as a resource for configuring the tool and writing custom plugins to transform JavaScript source code. The guide provides instructional material on creating custom transformation plugins and modifying the compilation process. It specifically covers how to navigate and modify abstract syntax trees to programmatically rewrite source code. The documentation covers the mechanics of code transformation, the management of compiler configurations, and the fundamentals of compiler tooling. It includes guidance

Optimize-js is a JavaScript parsing optimizer designed to reduce the time browsers spend pre-parsing scripts to improve initial execution speed. It transforms source code to minimize the overhead associated with browser parsing. The project implements a technique that wraps function calls in parentheses to bypass initial pre-parsing and reduce double-parsing overhead. To maintain the utility of the transformed code, it includes a source map generator that links the optimized output back to the original source. The toolset also includes performance benchmarking capabilities to measure the exa

Closure Library is a JavaScript standard library and utility toolset designed for building large-scale web applications. It provides a collection of core utility modules and standardized APIs to simplify complex application logic and state management. The project is built as a modular framework using a namespace-based module system to prevent global scope pollution. It is specifically designed for use with the Closure Compiler to enable aggressive dead-code elimination and minification, reducing the final delivery size in production. To ensure reliability in large projects, the library utiliz

ESTree is a formal schema and set of object interfaces used to represent JavaScript source code as a standardized abstract syntax tree. It serves as a common tree format and parser standard to ensure interoperability between different JavaScript parsers and transformation tools. The specification provides a consistent way to model language constructs, including statements, expressions, and module declarations. It includes detailed representations for modern language features such as classes, private identifiers, and short-circuiting logic like nullish coalescing and optional chaining. The pr

Recast is a JavaScript AST parser and printer designed for automated code refactoring. It converts source code into abstract syntax trees that can be modified and then printed back into source code. The project focuses on formatting-preserving transformations, storing original whitespace and indentation metadata within syntax tree nodes to reconstruct code without losing its original layout. It also generates character-level source maps to maintain precise correspondences between original input and transformed output. The toolkit includes utilities for syntax tree manipulation using a visito

Backpack is a Node.js build system designed for transpiling, bundling, and automating the development workflow. It functions as a JavaScript asset bundler that packages source files and dependencies into optimized output for production deployment. The system integrates a transpilation process to convert modern code into versions compatible with various environments and browsers. It provides an automated development workflow that watches for file changes to trigger automatic reloads and builds. The build pipeline supports configuration-driven customization, environment-specific targets, and i

Otto is a Go implementation of a JavaScript interpreter and embedded scripting engine. It provides a runtime environment for executing JavaScript code within native applications and includes a parser that converts source code into an abstract syntax tree for analysis and processing. The project enables the creation of custom scripting interfaces by binding native Go functions into the JavaScript global scope. It also includes a utility to translate JavaScript regular expression patterns into compatible formats for other programming languages. The engine supports safe script sandboxing throug

Flow is a JavaScript static type checker and AST parser that identifies type errors and prevents runtime failures through static annotations. It functions as a code intelligence engine and a static analysis linter to identify unsafe coding patterns and enforce consistency across a codebase. The project includes a type annotation stripper that removes static type signatures from source code, ensuring the resulting JavaScript is compatible with any runtime environment. It also provides a parser that converts typed JavaScript into an abstract syntax tree conforming to the ESTree specification.

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

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

This project is a comprehensive manual and educational resource focused on the Babel compiler. It serves as a documentation guide and handbook for understanding the inner workings of JavaScript compilation, specifically regarding the transformation of source code. The material provides a technical walkthrough for developing custom plugins and extensions. It covers the process of creating tailored transformations to modify how JavaScript is parsed and generated. The content encompasses the broader JavaScript compilation workflow, focusing on abstract syntax tree manipulation, code generation,

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

Scala.js is a compiler and cross-platform language toolchain that transforms Scala source code into JavaScript or WebAssembly. It functions as a statically typed tool for the JavaScript ecosystem, enabling the development of applications for web browsers and Node.js environments. The project serves as a JavaScript interop framework, allowing the creation of type-safe facades and bindings to interact with external libraries and global objects. It provides mechanisms for both static and dynamic JavaScript invocation, including the generation of TypeScript bindings and the ability to export inte

TeaVM is a Java bytecode transpiler and browser-based JVM runtime that converts compiled Java class files into JavaScript or WebAssembly. It functions as a compiler and build pipeline tool that enables applications written in various JVM languages to execute natively within a web browser. The project distinguishes itself by transforming bytecode directly into optimized web formats without requiring the original source code. It includes a WebAssembly bytecode compiler for high-performance execution and a specialized emulation system to handle asynchronous multithreading within the single-threa