August 2025

#Announcing Rsdoctor 1.2

Rsdoctor 1.2 has been released! 🎉

• Deep concatenated module analysis: Added the ability to analyze the size of concatenated modules, helping developers more accurately identify the actual build size after Tree Shaking.
• Bundle Size Analysis with Gzip Support: Bundle size analysis now displays the size after gzip compression, making it easier for developers to understand the real size of production assets.
• Enhanced Treemap Visualization: Introduced and improved the Treemap (rectangle tree map) feature, allowing developers to gain more intuitive insights into bundle composition and resource distribution.
• Rsdoctor MCP: Rsdoctor MCP is an LLM-powered build analysis tool that helps developers quickly obtain build analysis results through Q&A interactions.

#Deep concatenated module analysis

During the Rspack build process, certain modules are hoisted or aggregated into a single closure, forming a concatenated module to improve browser execution efficiency and reduce artifact size. Previously, Rsdoctor could not further decompose and analyze the internal structure of these concatenated modules, as they cannot be further split through AST parsing.

Rsdoctor 1.2 supports the ability to analyze concatenated module sizes, helping developers accurately understand the actual build size of sub-modules (aggregated modules) after tree shaking and compression, facilitating analysis of how concatenated modules affect final bundle size and optimization of code splitting strategies.

Additionally, the Rsdoctor plugin built into Rspack (>=1.4.11) has enhanced source map capabilities, allowing seamless analysis of concatenated modules without enabling source maps. However, Webpack projects still require source maps to be enabled.

View usage details

#Enhanced treemap visualization

Previously, Rsdoctor's Treemap view was implemented based on webpack-bundle-analyzer, which required Rsdoctor to go through webpack-bundle-analyzer's processing pipeline again after completing its analysis, reducing overall analysis efficiency. Additionally, Treemap page loading was slow, while Treemap is precisely the most commonly used visualization view for developers when analyzing bundles.

Rsdoctor 1.2 introduces a new classic Treemap artifact analysis view, helping developers more intuitively visualize and analyze bundle composition, Assets, and Modules proportions. You can also search for module resources, click on the module resource, and zoom in to the module area.

View usage details

#Support gzip size

To more accurately reflect production environment size performance, Rsdoctor has added support for analyzing gzip compressed sizes, which can be viewed on the Bundle Size page and TreeMap page, as shown below:

This shows a comparison between original size and gzip compressed size, providing more accurate reference data for production environment optimization.

#Rsdoctor MCP

Rsdoctor provides rich build analysis data, but developers need to spend time on page interactions and learning costs to perform build analysis and optimization. Therefore, we hope to leverage LLM for more intelligent build analysis to help users obtain analysis results more quickly.

Rsdoctor v1.1 introduced MCP support, which is based on Model Context Protocol (MCP) protocol, combining Rsdoctor's analysis capabilities with LLM's intelligent understanding abilities. Through natural language Q&A interactions, developers can quickly obtain build analysis results without needing to deeply understand complex analysis interfaces and data structures. Its main features include obtaining artifact information, dependency analysis, optimization suggestions, compilation performance, and tree shaking analysis among other core analytical capabilities.

Rsdoctor MCP supports natural language Q&A - you can directly ask questions like "Which packages have the largest volume?" or "Why wasn't this module tree-shaken?" The system will intelligently analyze and provide optimization suggestions, helping you quickly identify and resolve build issues.

View usage details

In addition, the 1.1-1.2 versions also included other capability changes. For complete update details, please refer to: Release page

March 19, 2025

#Announcing Rsdoctor 1.0

We are excited to announce the official release of Rsdoctor 1.0!

After a year of development and testing, we are proud to introduce Rsdoctor 1.0 — a build analyzer tailored for the Rspack ecosystem and fully compatible with the webpack ecosystem.

Rsdoctor is committed to being a one-stop, intelligent build analyzer that makes the build process transparent, predictable, and optimizable through visualization and smart analysis, helping development teams precisely identify bottlenecks, optimize performance, and improve engineering quality.

#Why Rsdoctor

In the field of build analysis, the community already has some mature tools, such as webpack-bundle-analyzer for visualizing bundles, and Statoscope for comprehensive resource analysis. In addition, speed-measure-webpack-plugin can be used to analyze the execution time of plugins and loaders, and locate build performance bottlenecks.

However, these tools still have some shortcomings, such as lack of detailed display of build details, lack of comprehensive build problem analysis capabilities, incompatibility with Rspack, and lack of build warning scanning capabilities.

In summary, community tools have the following areas for improvement:

1. Lack of detail: Traditional tools cannot delve into the details and changes of the build process, and to view the compilation details of a loader, developers often need to set breakpoints for step-by-step debugging.
2. Functional limitations: Current analyser typically only display bundle data, lacking build scanning capabilities, unable to proactively provide optimization suggestions, and do not support custom scanning rules.
3. Support for Rspack: Existing tools do not fully support Rspack, for example, they cannot analyze Rspack's builtin loader of Rspack.

#Birth of Rsdoctor

Based on the above situation, we decided to develop a build analyzer focused on the Rspack ecosystem — Rsdoctor.

We designed an intuitive user interface for Rsdoctor, and Rsdoctor extends the loader profiling capability by combining the advantages of multiple tools to more deeply analyze the loader behavior in the compilation phase, built-in the scanning and detection rules for artifacts and compilation, and supports user custom rules.

Rsdoctor not only supports Rspack and webpack, but also supports all tools and frameworks based on Rspack or webpack, such as: Docusaurus, Rspeedy (Lynx), Storybook, Next.js, Nuxt, Re.Pack, Modern.js, Rsbuild, Rspress and Rslib.

Rsdoctor can be used to:

• As a build analyzer: Help developers understand every aspect of the build process, and provide detailed compilation and bundle analysis.
• As an extensible analysis tool: Allow developers to customize analysis rules according to project requirements, and achieve targeted optimization of the build process.

#Who is using

Rsdoctor has been widely used within ByteDance, helping developers efficiently analyze and solve various problems in the build process.

Since its open source in 2024, Rsdoctor's npm weekly downloads has exceeded 100k. In the community, Rsdoctor has been integrated into frameworks such as Docusaurus and Lynx. In addition, Rsdoctor has also been adopted by large projects such as Sentry, NocoBase and Grafana.

In the future, Rsdoctor will continue to provide first-class support for all tools in the Rstack (Rspack stack abbreviation) ecosystem:

#Typical use cases

Rsdoctor offers a rich set of features, detailed content can be found in the Feature Navigation. Here are some typical use cases that demonstrate how Rsdoctor effectively solves common build problems:

#1. "Why is the build speed too slow?"

During the build process, if you find that the compilation speed is too slow, you can use the Loader Timeline to view the time consumption of loader execution, and understand the compilation time consumption of each file by each loader. This way, you can find loaders with excessive time consumption.

#2. "Outputs are not as expected?"

During the build, there may be problems where the outputs do not match expectations, such as runtime exceptions or style errors. The Loader Details page of Rsdoctor can help you examine the changes made by the loader to a specific file before and after compilation.

#3. "How to split the chunks reasonably?"

We can use the Bundle Analysis page to look at the modules tree of a particular artifact to see what modules the chunk contains, and then use the splitChunks configuration of Rspack to split the chunks appropriately.

#4. "How to analyze the reasons for the increase in bundle size?"

When a certain version is launched, if the performance of the online page deteriorates due to the increase in the size of the artifact, you can use the Bundle Diff feature of Rsdoctor to compare the details of the bundles of two commits, as well as the changes in the npm packages they depend on.

#5. "Why is a certain module bundled?"

During the build process, if you want to know why a certain module file is bundled into the artifact, you can click on the Module Graph icon behind the module in the Modules tree on the Artifact Analysis page to view the upstream dependency relationship of the module.

#What's new in 1.0

#🎨 Brand new UI

In version 1.0, we have comprehensively optimized the user interface of Rsdoctor, making it more clear, elegant, and easy to navigate. The new design is dedicated to improving the user experience, making information display more intuitive and efficient.

#🚀 Faster analysis

In large projects, enabling Rsdoctor can increase the overall build time. To solve this problem, we rewrote the time-consuming data processing logic in Rsdoctor in Rust, and integrated it into Rspack.

This optimization effectively improves the build analysis performance of Rsdoctor, and reduces the overall analysis time by more than 20%. In the future, we will continue to native more modules to further improve the analysis efficiency.

This optimization can be enabled through the enableNativePlugin option:

new RsdoctorRspackPlugin({
  experiments: {
    enableNativePlugin: true,
  },
});

#🔍 Module searching

• Search Module Capability: In the Bundle Size page, we have added a module search function. Users can quickly locate and view the Assets where the module is located by entering the module name, making it more convenient to analyze the reference relationship and size of the module. Details

#🛠️ New scanning rules

• Duplicate package detection: Added a rule for detecting duplicate packages across chunks, which can scan for duplicate packages in different chunks. These duplicate packages may cause redundant code in the build.
• ECMA version checking: Enhanced the ECMA version detection rule, used to detect incompatible advanced syntax.

new RsdoctorRspackPlugin({
  linter: {
    rules: {
      'ecma-version-check': [
        'Warn',
        {
          ecmaVersion: 2015,
        },
      ],
    },
  },
});

#How to use 1.0

• If you are using any tool or framework based on Rspack or webpack, you can refer to the Quick Start to start using Rsdoctor.
• If you are using Rsdoctor 0.4 or earlier, please note that 1.0 contains a few incompatible updates:
  • The reportCodeType and reportDir configuration items in the plugin configuration have been moved to output.

Welcome to give a star 🌟 to the Rsdoctor GitHub repository.

#Next steps

• AI powered analysis: The build analysis data collected by Rsdoctor is very rich, but there may be a certain learning curve for new users. Therefore, we will integrate AI capabilities into Rsdoctor to help users quickly extract key information from massive data, provide intelligent optimization suggestions, and reduce the threshold of build analysis.
• CI proactive monitoring: Rsdoctor will extend its capabilities in CI environments by introducing Rsdoctor CI Action, based on the existing Bundle Diff feature. This will provide automated monitoring of bundle sizes and alerts for performance issues to ensure quality.
• Further Native: Due to the implementation of Rspack in Rust and the use of a multi-threaded architecture, the current analysis of the built-in loader of Rspack by Rsdoctor is not accurate enough. We plan to optimize the analysis mechanism based on Rspack Native Plugin, and provide more accurate loader performance data and compilation behavior insights.

Finally, thank you to all the developers who have contributed to Rsdoctor ❤️:

@9aoy、@bin1357、@cairon666、@cclap2020、@charpeni、@chenjiahan、@ChuHoMan、@cnryb、@Gehbt、@gezhicui、@HigherOrderLogic、@iamleniac、@inottn、@jkzing、@KyrieLii、@kwonoj、@LingyuCoder、@nanianlisao、@nhducit、@NickBolles、@nyqykk、@puppet-666、@SoonIter、@sudhakar-s、@Timeless0911、@tinywaves、@trueLoving、@wChenonly、@zllkjc。

October 09, 2024

#Announcing Rsdoctor 0.4

Rsdoctor 0.4 is now released!

The new features of Rsdoctor 0.4 include:

• Brief Mode: Outputs a single HTML file, ideal for CI processes.
• Bundle Diff: Compare and analyze changes between two build artifacts.
• Vue Loader Analysis: Added support for loader analysis in Vue projects.

#Brief mode

In Rsdoctor 0.4, a new Brief mode has been added, designed specifically for CI/CD scenarios. Brief mode consolidates the data report into a single HTML page, making it convenient for users to view historical build data in CI/CD and other scenarios. The main features of Brief mode are:

• Single report file: Previously, Rsdoctor output multiple report data and Manifest.json, which was inconvenient for CDN upload and sharing. Brief mode outputs a single report, making it convenient for use in CI processes.
• Easy to configure: Enable by configuring the mode.brief option in the Rsdoctor plugin.
• Report output: The report will be generated in the build artifacts directory, and the output directory and filename of the Brief report can be configured.

This feature greatly enhances the convenience of using Rsdoctor analysis reports in CI processes. The report can be uploaded to a CDN in the pipeline to display historical reports. For more details, please refer to

#Bundle diff

The Bundle Diff feature helps users compare and analyze changes between two build artifacts. Key capabilities include:

• Total size change: Displays the total size change between two build artifacts.
• File type change: Compares the size changes of different types of files (JS, CSS, images, fonts, etc.).
• First screen resource change: Analyzes the size changes of resources loaded on the first screen.
• Duplicate package count change: Counts and compares the number of duplicate packages between two builds.
• NPM Packages change: Displays changes in the number of NPM packages, including added, removed, and changed packages.
• Detailed data query: Provides a detailed list module for deeper data query and analysis.
• Module-level comparison: View the name, size, and change rate of modules, and supports viewing the code changes of modules.

This feature enhances the user's ability to visually analyze changes in build artifacts, helping users better understand and optimize build results. For more details, please refer to

#Next

Plans to support Bundle Diff Action on GitHub to simplify degradation monitoring during the CI phase.

#Vue loader analysis

Support for loader analysis for Vue projects has been added in Rsdoctor 0.4.

#Other features

• Rspack's builtin:lightningcss-loader analysis: Added support for builtin:lightningcss-loader analysis.

• Performance optimization:

  • Reduced the size of the @rsdoctor/client package by 60%, improving page rendering speed.
  
  • Reduced third-party dependencies, thereby reducing the total download size during installation.

June 02, 2024

#Announcing Rsdoctor 0.3

Rsdoctor 0.3 has been released!

The new features of Rsdoctor 0.3 include:

• Custom Extension Rules: Users can customize their own rule checks through the interface.
• Support for Banner Plugin: Added support for the Banner Plugin, which adds template wrapping to the bundled code, allowing analysis of code changes.
• Support for ESM Loader Analysis: Added support for analyzing ESM Loaders in the compilation analysis in Rspack.

#Custom extension rules

Considering that users may have their own specific rule definition requirements, Rsdoctor provides an external interface for users to customize their own rule checks in addition to the internal rules already available. External extension interfaces need to be configured on the Rsdoctor plugin through the extends field, and their configurations are also placed in the rules field.

For more details, please refer to: Custom Extension Rules

Additionally, the use of custom rules can also be applied for user data collection and reporting. Data Reporting

• Example:

// src/rules/assets-count-limit.ts
import { defineRule } from '@rsdoctor/core/rules';

export const AssetsCountLimit = defineRule(() => ({
  meta: {
    category: 'bundle',
    severity: 'Warn',
    title: 'assets-count-limit',
    defaultConfig: {
      limit: 10,
    },
  },
  check({ chunkGraph, report, ruleConfig }) {
    const assets = chunkGraph.getAssets();

    if (assets.length > ruleConfig.limit) {
      report({
        message: 'The count of assets is bigger than limit',
        detail: {
          type: 'link',
          link: 'https://rsdoctor.rs/zh/guide/start/quick-start', // This link just for show case.
        },
      });
    }
  },
}));

// rsbuild.config.ts
import { AssetsCountLimit } from './rules/assets-count-limit';

export default {
  tools: {
    bundlerChain: (chain) => {
      chain.plugin('Rsdoctor').use(RsdoctorRspackPlugin, [
        {
          linter: {
            level: 'Error',
            extends: [AssetsCountLimit],
            rules: {
              'assets-count-limit': [
                'on',
                {
                  limit: 1, // rule custom configs
                },
              ],
            },
          },
        },
      ]);
    },
  },
};

#Support for banner plugin

Both Rspack and webpack support the BannerPlugin, which is an built-in plugin that allows you to add specific content at the top or bottom of the generated chunks. The added code will affect the parsing capability of the bundle.

Therefore, Rsdoctor has added support for the Banner Plugin.

Please refer to Support for BannerPlugin

#Support for ESM loader

Starting from Rspack@0.7.3, support for ESM Loader execution with .js extension and type: module configuration in package.json is added (related issue). Therefore, Rsdoctor also supports the analysis of ESM Loader, mainly supporting the following two types:

1. ESM Loader with .mjs extension.
2. ESM Loader with .js extension and type: module configuration in package.json.

#Support for defining port

Support for defining the port of Rsdoctor service has been added.

• Example:

chain.plugin('Rsdoctor').use(RsdoctorRspackPlugin, [
  {
    port: 8888, // port
  },
]);

#Support for parse bundle configuration

In some large repositories, the execution time for parsing bundles is significant. This is because the Parse Bundle analysis relies on AST parsing and processing, which can be time-consuming when there are a large number of files. If this capability is not necessary, it can be selectively disabled using the supports.parseBundle configuration. Here is an example:

chain.plugin('Rsdoctor').use(RsdoctorRspackPlugin, [
  {
    supports: {
      parseBundle: false,
    },
  },
]);

Disabling the Parse Bundle capability only affects the ability to view the final bundled size and code of modules in the bundle (Bundled Code).

January 24, 2024

#Announcing Rsdoctor 0.1

We are excited to announce the release of Rsdoctor 0.1!

Rsdoctor is a one-stop build analyzer for Rspack and Webpack. It allows for detailed analysis of the build process and bundles, making the build process more visual and transparent.

#📌 Position

Rsdoctor is a build analyzer for analyzing projects built with Rspack and Webpack. It supports analysis of projects such as Rsbuild, Create React App, Modern.js, and more.

#🔥 Features

• Compilation Visualization: Rsdoctor visualizes the compilation behavior and time consumption, making it easy to view build issues.
• Multiple Analysis Capabilities: Rsdoctor supports build artifact, build-time analysis, and anti-degradation capabilities:
  • Build artifact support for resource lists and module dependencies, etc.
  • Build-time analysis supports Loader, Plugin, and Resolver building process analysis, including Rspack's builtin loaders.
  • Build rules support duplicate package detection and ES Version Check, etc.
  • Currently, bundle diff capabilities are also available.
• Support Custom Rules: In addition to built-in build scan rules, Rsdoctor also supports users adding custom component scan rules based on the build data of Rsdoctor.
• Framework-Independent: Rsdoctor support all projects built on Rspack or webpack.

#🛠️ Introduction

#⭐️ Overview

• The overview page (i.e. the home page) can know project configuration, diagnostic information, compilation information, and product status.

• In addition to the project overview, we also provide diagnostic functions, including compilation diagnostics and duplicate packages diagnostics. If your compilation and products hit the diagnostic rules we defined, the corresponding warning alerts will appear on the tool's home page. where you can see the detailed reference path of duplicate packages:

#⭐️ Compilation analysis

Provides corresponding data and analysis functions for Loaders, Plugins, and Module Resolve to help you analyze problems in the compilation process.

#Loader analysis

• This module mainly provides the function of data analysis such as input and output, estimated time consumption, and parameters within Rspack or webpack Loaders.

#Plugin analysis

• This module mainly intercepts and collects data information such as the number of calls and estimated time consumption of Plugins.

#Resolve analysis

• This module mainly provides path data and estimated time consumption for module resolution in a single file within the project. Rspack does not currently support this module.

#⭐️ Product analysis

• In the Bundle Size page, we can see an overview of the product data information of the current project, as well as analyze the size and reasons for duplicate package imports.

• In addition, we can also use the Bundle Analysis page to further analyze the relationship between the product and module in the current product, size data and other information, as well as the reasons for module introduction.

#📚 Quick start

You can refer to the Quick Start to get started with Rsdoctor.

#💡 Next steps

Improve Rsdoctor build analysis efficiency: Currently, enabling Rsdoctor plugin increases project build time. In the next step, we will extract and convert some of Rsdoctor's build analysis logic into a rust plugin, built-in to Rspack, in order to improve Rsdoctor's build analysis efficiency.

#Acknowledgements

Rsdoctor has been inspired by outstanding projects in the community, and we would like to express our gratitude to them:

• Refer to the analysis logic of artifact relationships from bundle-stats.
• Refer to the module breakdown and analysis logic from webpack-bundle-analyzer.
• Statoscope is an excellent tool for analyzing build artifacts, and Rsdoctor is inspired by it in terms of build analysis.
• Webpack team and community have created an excellent bundling tool and a rich ecosystem.
• vite-plugin-inspect has inspired Rsdoctor's exploration of build process analysis.