Tagged articles
esbuild
32 articles · Page 1 of 1

大转转FEJun 25, 2026 · Backend Development
The author refactors a 1,021‑line, zero‑test IM conversion module that is referenced in five places by building a characterization‑test net with esbuild stubs, generating 130 exhaustive samples, recording a golden baseline, applying three systematic code transformations, and verifying behavior and a 2.77× speedup, all without touching business logic.
AICharacterization TestJavaScript
0 likes · 16 min read

This article provides a concise overview of tree shaking mechanisms in major JavaScript bundlers—Webpack/Rspack, esbuild, Turbopack, and Rollup—explaining their implementation stages, static analysis techniques, optimization trade‑offs, and practical code examples that highlight each tool's strengths and limitations.
RollupTurbopackcode optimization
0 likes · 20 min read

This article explains how Vite achieves fast development by serving ES modules directly, using a connect‑based dev server with plugin‑driven transforms, pre‑bundling dependencies via esbuild, generating hash‑based cache keys, and reusing the same plugins in Rollup for production builds.
Pre‑bundlingRollupdev server
0 likes · 9 min read

By leveraging native code tools like esbuild, caching strategies, and a custom pre‑compilation workflow that fakes Webpack's DllPlugin output, this article shows how Mars framework teams dramatically cut compilation times—up to 40% faster—while handling module resolution, resource handling, and cross‑platform challenges.
Build Optimizationesbuildfrontend
0 likes · 14 min read

This article explains how Vite speeds up frontend development by serving unbundled ES modules, using a plugin‑based transform pipeline, performing on‑the‑fly compilation, pre‑bundling dependencies with esbuild, and finally leveraging Rollup for production builds while maintaining consistent behavior across dev and prod environments.
Build ToolsESMFrontend Development
0 likes · 9 min read

Vite accelerates development by serving unbundled ES modules directly to the browser, using a connect‑based dev server that compiles on‑demand, leverages esbuild for fast pre‑bundling of dependencies, generates hash‑based cache queries, and shares plugins with Rollup for consistent production builds.
Build ToolsFrontend DevelopmentHot Module Replacement
0 likes · 9 min read

This article provides an in‑depth tutorial on using esbuild as a fast frontend bundler, covering its basic features, loader support, plugin ecosystem, source‑map options, path aliasing, external CDN handling, code compression, CSS compatibility, tree‑shaking, code‑splitting, hash‑based filenames, build‑time cleaning, environment variables, and TypeScript type checking.
ConfigurationTypeScriptbuild-tool
0 likes · 34 min read

This article explains why Vite is faster than bundlers like Webpack, introduces the concept of dependency pre‑bundling, walks through its implementation using esbuild plugins, and shows how to build a simplified custom Vite server that scans, resolves, and pre‑bundles third‑party modules.
Build ToolsJavaScriptPre‑bundling
0 likes · 35 min read

The article chronicles the technical background, challenges, and design decisions behind building a Rust-powered web bundler, comparing it with existing tools like Webpack, Vite, Rollup, and esbuild, and outlines future directions for improving plugin APIs, AST reuse, and build performance.
AST reuseRustesbuild
0 likes · 23 min read

Angular v16 introduces a suite of groundbreaking features—including a developer preview of Signals, enhanced server‑side rendering hydration, an esbuild‑based CLI, standalone component migration, updated package formats, and deprecations—while requiring Node.js 16/18 and TypeScript 4.9 or newer.
AngularSignalsesbuild
0 likes · 9 min read

This article explores the history, underlying mechanisms, and practical comparisons of frontend build tools—from early YUI and Ant scripts through AMD/CMD, Grunt/Gulp, Webpack, Rollup, esbuild, and Vite—illustrating how they transform development code into optimized production assets and addressing common performance and configuration challenges.
Build ToolsRollupVite
0 likes · 24 min read


ByteFEMar 1, 2023 · Frontend Development
This article explores the evolution, core principles, and comparative analysis of frontend build tools—from early YUI/Ant and AMD/CMD to modern solutions like Webpack, Rollup, esbuild, and Vite—detailing their functionalities, implementations, performance considerations, and common challenges for developers.
Build ToolsModule BundlingRollup
0 likes · 25 min read

This article walks through why Vite dramatically speeds up development, explains its architecture, and provides a step‑by‑step guide—including configuration changes, dependency installation, and common pitfalls—to successfully migrate a Vue 2 project built with Vue‑CLI to Vite.
Build ToolsViteesbuild
0 likes · 11 min read

This article explores Vite’s evolution and core architecture, detailing how it improves development server startup time, performs dependency pre‑bundling with esbuild, creates the dev server, handles HTML injection, and implements fast hot‑module replacement through WebSocket communication.
ESMFrontend DevelopmentHot Module Replacement
0 likes · 12 min read

Vite improves dev‑server startup and runtime speed by scanning every project HTML file (excluding node_modules) with an esbuild plugin that traverses the module graph, classifies JavaScript, assets, bare imports and framework files, creates virtual modules, and records each bare import’s actual path for pre‑bundling.
Dependency ScanningHTMLJavaScript
0 likes · 18 min read

This article explores how the Go‑based esbuild bundler can be used as a regular npm package in JavaScript, detailing the inter‑process communication protocol, binary encoding, and a minimal Node.js codec that enables fast, cross‑language API calls.
IPCJavaScript APINode.js
0 likes · 11 min read

This article explains the bundle‑less approach—including splitting bundles, no‑bundle development, and modular dependency distribution—presents performance tests that suggest an optimal chunk count of 10‑25, evaluates Vite’s advantages and drawbacks, and outlines a self‑built import‑map‑based solution with code examples.
Vitebundle-lessesbuild
0 likes · 19 min read

This article describes how to add Hot Module Replacement to esbuild by disabling scope hosting, converting modules to CommonJS, building a custom ModuleLoader and resolver, handling module URLs, and comparing two bundling approaches while also covering React Refresh integration.
HMRReact Refreshesbuild
0 likes · 9 min read

Tree shaking, a subset of dead‑code elimination based on ES2015 module syntax, removes unused top‑level code, while side‑effect analysis determines which modules can be safely omitted; this article explains the terminology, algorithms, safety vs optimization trade‑offs, and practical debugging steps for modern JavaScript bundlers.
JavaScript bundlersdead code eliminationesbuild
0 likes · 19 min read

This article explains what ESBuild and SWC are, why they dramatically speed up JavaScript bundling and compilation compared to traditional tools, and provides practical guidance on integrating them into modern frontend workflows such as Vite, Webpack, and custom scripts.
Frontend Build ToolsGoJavaScript bundler
0 likes · 18 min read

This article explains how Umi 4 accelerates the build phase by replacing traditional terser and cssnano compressors with esbuild, details configuration for JS and CSS minifiers, describes dependency compilation optimizations, and introduces remote caching to further reduce build times.
Build OptimizationCachingUMI
0 likes · 6 min read


ByteFEApr 18, 2022 · Frontend Development
This article provides a comprehensive overview of Vite, covering its motivation as a modern frontend toolchain, core features such as native ES‑module dev server, fast dependency pre‑bundling with esbuild, production builds via Rollup, and detailed explanations of its plugin architecture and debugging utilities.
dependency prebuilddev serveresbuild
0 likes · 15 min read


WeChatFEMar 22, 2022 · Frontend Development
After upgrading a project to Vite, users on iOS 11 experienced blank pages due to compatibility issues caused by esbuild’s minification generating modern syntax; the article explains the root cause, examines legacy plugin settings, and shows how explicitly setting esbuild.target to 'es6' (or using terser) resolves the problem.
Frontend BuildViteesbuild
0 likes · 8 min read


58 TechMar 10, 2022 · Frontend Development
This article provides a comprehensive tutorial on Vite, explaining its core principles, architecture, and practical implementation, while detailing a step‑by‑step migration from Webpack—including handling JSX, aliasing, module resolution, CSS, HMR, and performance improvements—complete with code snippets and real‑world challenges.
Build ToolsFrontend DevelopmentHMR
0 likes · 24 min read

This article provides a comprehensive overview of Vite, covering its definition, advantages over traditional bundlers like Webpack and Snowpack, the underlying ESM‑based development server, hot‑module replacement mechanisms, esbuild pre‑bundling, Rollup integration, plugin architecture, and a balanced summary of its strengths and limitations.
ESMHMRRollup
0 likes · 19 min read

This article explores the architecture and implementation of a universal bundler based on esbuild, detailing its plugin system, virtual module capabilities, and strategies for adapting bundling processes to browser environments while addressing CommonJS compatibility, file system abstraction, and performance optimization.
BundlerCommonJS compatibilityesbuild
0 likes · 25 min read


ByteFEJan 7, 2022 · Frontend Development
This collection presents a variety of recent frontend‑focused articles and tutorials—including WebGPU fundamentals, low‑code implementation principles, Esbuild performance tricks, design‑pattern insights, TypeScript type programming, NestJS dependency injection, Pinia state management, image‑loading optimization, and Immer.js immutable data handling—each accompanied by QR‑code links to the original sources.
NestJSPiniaWebGPU
0 likes · 7 min read


Aotu LabSep 24, 2021 · Frontend Development
This article explores how to speed up Webpack builds with esbuild-loader, implements dynamic treemap visualizations for NetEase Cloud Music’s social voting feature, introduces XState’s finite‑state‑machine approach to state management, explains the inner workings of TypeScript, and provides a deep dive into the V8 JavaScript engine.
State ManagementTypeScriptV8
0 likes · 7 min read


ByteFEJun 2, 2021 · Frontend Development
This article examines the performance challenges of traditional bundled development with Webpack, evaluates emerging unbundled tools such as Snowpack, WMR, and Vite, and details the design and implementation of a custom unbundled dev server that accelerates startup, handles dependency preprocessing, resource transformation, and hot module replacement.
Vitedev-serveresbuild
0 likes · 22 min read

This article analyses the performance problems of traditional bundled development with Webpack, explores unbundled tools such as Snowpack, WMR and Vite, and details a custom dev‑server implementation that leverages CJS‑to‑ESM conversion, esbuild bundling, plugin architecture, and fast HMR to dramatically reduce startup time for large monorepos.
DevToolsViteesbuild
0 likes · 19 min read

This article walks through the source‑code analysis of Vite, explains why Vite rewrites import paths and creates a .vite folder, and provides a complete, minimal implementation of a Vite‑like development server using esbuild, connect middleware, and Vue SFC compilation.
Vitedependency pre‑bundlingesbuild
0 likes · 19 min read


ByteFEMar 16, 2021 · Frontend Development
This article explains the motivation, architecture, and implementation details of a universal bundler built on esbuild, covering bundler fundamentals, plugin systems, virtual modules, browser compatibility challenges, node module resolution, and practical usage scenarios for both frontend and backend development.
Bundleresbuildplugin system
0 likes · 27 min read
