Open-source alternatives to Plugins

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

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

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

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 browser-based code playground and web development sandbox designed for front-end experimentation, prototyping, and educational use. It provides an interactive workspace where users can write, transpile, and execute HTML, CSS, and JavaScript snippets to receive immediate visual feedback. The environment distinguishes itself through an integrated JavaScript module bundler that resolves and loads external dependencies directly in the browser. By utilizing import maps and in-browser transpilation, the system enables the use of modern syntax and third-party libraries without requ

This project is a comprehensive guide and educational resource for the TypeScript language. It covers the fundamental principles of the language, including its structural type system, static type analysis, and the process of transpiling typed source files into JavaScript. The material details how to model complex data and reusable type logic using generics, conditional types, and mapped types. It also explains the use of declaration files to provide type safety for external JavaScript libraries and the integration of type checking into existing JavaScript projects via JSDoc annotations. The

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

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

Rushstack is a comprehensive toolset for managing large-scale TypeScript monorepos, providing a framework for build pipeline automation, dependency coordination, and static analysis. It functions as an incremental build orchestrator and management system designed to maintain consistency and performance across multiple packages in a shared workspace. The system distinguishes itself through an execution model based on directed acyclic graphs and content-hash-based incrementalism, which ensures only affected projects are rebuilt. It further optimizes development workflows via remote build artifa

c2rust is a source-to-source translation suite and C-to-Rust transpiler designed to convert C source code and libraries into functionally equivalent unsafe Rust code. It operates as a pipeline that preserves original behavior and data structures, producing translated code that compiles as compatible shared libraries or Rust crates. The system includes an automated Rust refactoring framework that uses pattern-based AST rewriting to transform unsafe Rust into safe, idiomatic constructs. It utilizes an ownership inference engine to determine when raw pointers can be converted into safe reference

CoffeeScript is a source-to-source transpiler that transforms a concise high-level syntax into standard JavaScript. It enables the development of logic for web applications and server-side environments by converting source code into a format compatible with browsers and server runtimes. The project provides a workflow for rapid prototyping and script execution automation, allowing users to run source files through a compiler and execute the resulting code immediately without a manual build step. The tooling leverages lexical analysis and abstract syntax tree transformations to manipulate cod

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

Fuse-Box is a JavaScript bundler, module loader, and development web server. It packages JavaScript source files into optimized bundles for execution in both browser and server environments. The project manages the front-end development workflow by combining asset bundling with a local server to preview application changes in real time. It includes a programmatic API for loading and executing JavaScript modules in the browser. The system handles JavaScript asset bundling and module loading through dependency-graph analysis and dynamic entry-point resolution. It employs an incremental build p

tsdown is a library bundler that uses a Rust-native core, built on Rolldown and the Oxc parser, to compile TypeScript and JavaScript source code into optimized output files. It is designed to produce bundles in multiple formats—ESM, CJS, IIFE, and UMD—from a single source, and automatically generates TypeScript declaration files during the build process for type-safe distribution. The project distinguishes itself by offering a plugin system compatible with Rollup, Rolldown, unplugin, and some Vite plugins, allowing the build pipeline to be extended with custom transformations. It also accepts

Codemod is a set of software tools for performing structural source code transformations. It functions as an automated codebase migration tool that utilizes abstract syntax tree manipulations rather than simple regular expressions to execute large-scale refactors across multiple files. The project distinguishes itself through an interactive transformation interface that provides colored diffs, allowing users to manually review, accept, or modify each match. It also supports a distributed refactoring workflow, which enables the segmentation of a codebase into assigned work blocks to divide mig

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,

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

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

This project is a suite of abstract syntax tree transformation tools designed to automate the migration of source code to newer versions of React. It provides a set of scripts that programmatically modify code structures to replace deprecated APIs and component patterns with modern equivalents. The toolkit specializes in converting class components into functional components using arrow functions and prop destructuring. It also includes utilities for modernizing JSX syntax, updating deprecated lifecycle methods to stable versions, and migrating legacy string-based references to callback refs.

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

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

Binaryen is a WebAssembly compiler toolchain and optimizer designed to transform, validate, and shrink binary modules. It provides a comprehensive intermediate representation framework that converts binary code into a single-assignment form to enable advanced program analysis and code transformation. The project includes a specialized transformation engine that applies iterative optimization passes to increase execution speed and reduce binary size. Additionally, it functions as a transpiler that translates WebAssembly binary modules into executable JavaScript for environments that lack nativ

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

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

Utopia is a development platform for building React components through a visual interface that synchronizes changes directly with underlying source code. It functions as an AST-based code editor and a visual component editor, using abstract syntax tree manipulation to update files while preserving the original formatting and structure. The project features an in-browser module bundler that compiles and executes JavaScript modules directly within the browser to provide immediate feedback without server-side build steps. It also includes a pull request preview tool for inspecting and validating