Rolldown

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, including module resolution management, code splitting, and multi-format output generation. It also provides developer experience features such as hot module replacement, file change watching, and source map generation for debugging.

The project provides a hook-based plugin architecture that allows for custom logic injection during the resolution, loading, and transformation stages.

Features

Rust-Implemented Tooling - Implements a high-performance bundling core written in Rust for efficient execution across JavaScript environments.

Module Bundlers - Combines JavaScript and TypeScript source files and their dependencies into unified ECMAScript Module output artifacts.

Build Pipeline Customizers - Provides a plugin interface to customize how files are processed, transformed, and optimized.

Lazy Evaluation Graphs - Defers the processing of source files until they are explicitly requested by the dependency graph.

Dependency Resolution - Provides mechanisms for mapping module names and import statements to physical file locations.

Output Formatting Utilities - Produces bundles in various formats such as ESM and CommonJS to ensure compatibility across environments.

Module Format Renderers - Translates a module graph into specific JavaScript distribution formats such as ESM and CommonJS.

Source Bundling - Combines multiple JavaScript and TypeScript files into a single output file to reduce network requests.

Lazy Module Compilation - Uses a Rust-based engine with lazy compilation to significantly reduce the time spent resolving and transforming source code.

Compatibility Layers - Provides a compatibility layer that implements the Rollup API to ensure seamless integration with existing plugins and workflows.

Lazy Compilation - Defers module processing until requested to speed up the initial build and startup time.

Module Resolution - Implements algorithms and configuration logic to map module identifiers to specific file paths during the build process.

Module Path Resolution - Locates code items within the module tree using absolute paths, relative paths, and configuration-based aliases.

Rollup Compatible Bundlers - Implements a Rollup-compatible API to ensure compatibility with existing workflows and the established plugin ecosystem.

Hook-Based Plugin Systems - Exposes a set of lifecycle hooks that allow external plugins to intercept and modify module resolution and transformation.

Code Splitting - Divides the output into smaller files using dynamic imports and manual grouping to optimize loading performance.

Frontend Asset Optimization - Reduces final bundle sizes using tree shaking, minification, and code splitting to improve website performance.

JavaScript Bundlers - A high-performance JavaScript bundler written in Rust that compiles and packages modules for web deployment.

JavaScript Bundling Workflows - Combines JavaScript and TypeScript files into optimized bundles for web applications.

Tree-Shaking Optimizations - Eliminates dead code by analyzing the module graph to remove unused exports and side-effect-free calls.

Tree-Shaking Optimizers - Uses static analysis to remove unused code during the build process to optimize final delivery size.

Module Federation - Shares code between different builds at runtime using remote entry points and coordinated versioning.

Abstract Syntax Tree Transformers - Implements tools that allow modification of the source code structure during the bundling process.

Code Splitting - Divides the output into multiple smaller files via dynamic imports to optimize initial loading speed.

Bundling Plugins - Provides programmable extensions that allow developers to customize how the engine resolves IDs, loads files, and renders chunks.

Fast Development Iteration - Provides real-time code updates without full page reloads through a high-performance Rust build process.

Hot Module Replacement - Updates running application code without reloading the page by applying real-time runtime patches.

Source Map Generators - Generates source maps that link the bundled output back to the original source code for debugging.

Chunking Strategies - Implements custom configurations for splitting code into optimized bundles using manual groups or size patterns.

Code Transformation Engines - Performs static analysis and syntax conversion to modify source code during the build process.

File Change Detection - Monitors source files and triggers automatic rebuilds whenever a change is detected.

JavaScript Minification - Reduces final bundle size through whitespace removal, identifier optimization, and shortening variable names.

Build Systems - High-performance JavaScript/TypeScript bundler written in Rust.

rolldownrolldown

Features

Star history