Bun is an all-in-one JavaScript/TypeScript toolkit shipped as a single native executable: a JavaScriptCore-powered runtime, an npm-compatible package manager, a bundler/transpiler, and a Jest-compatible test runner. The code confirms this: src/bun_bin is the CLI entry point; src/install is a full package manager with its own binary lockfile format, workspaces, and isolated/hoisted installers; src/bundler, src/css, and src/js_parser implement JS/TS/JSX/CSS/HTML bundling and transpilation; src/jsc and src/runtime implement the runtime with Web platform APIs, an HTTP server (Bun.serve), WebSocket support, SQL clients, and a Node.js compatibility layer (src/js/node, src/js/internal). It also embeds a React Compiler port for automatic memoization and a shell interpreter (Bun.shell). The repo is fundamentally an application, not a data/research project; the only research-flavored content is compiler-semantics fixture corpus and benchmark scripts.
Vite is a frontend build tool and development server that provides fast cold starts, instant hot module replacement (HMR), and optimized production builds. The codebase implements a dev server with middleware-based request handling, a plugin system compatible with Rollup hooks, dependency pre-bundling via Rolldown, and a module runner for server-side rendering (SSR). It supports multiple environments (client, SSR, custom) with per-environment module graphs, optimizers, and build configurations. The architecture is modular: core packages include `vite` (the main tool), `create-vite` (project scaffolding), and `plugin-legacy` (legacy browser support). Key entry points are the CLI (`bin/vite.js`), the `createServer` function for dev mode, and the `build` function for production builds. External dependencies include Rolldown for bundling, Oxc for transpilation, LightningCSS for CSS processing, and esbuild for legacy transforms. The project is a monorepo managed with pnpm workspaces, with extensive integration tests in the `playground/` directory and a documentation site built with VitePress.
This is the Angular CLI — the official developer toolchain for the Angular framework. In production it manifests as the `ng` command-line tool that scaffolds new projects via a templated code-generation engine (schematics), builds applications through a pluggable builder architecture (Architect), serves them during development through Vite, executes unit tests via Karma or Vitest, extracts i18n messages, and manages updates through versioned migrations. The repository also ships `@angular/ssr`, a Node.js server-side rendering runtime with HTTP/1.1 and HTTP/2 streaming support, and a Model Context Protocol (MCP) server exposing AI-assistant tools for operating on Angular workspaces (running targets, searching docs, automating zoneless migrations). Architecturally this is a monorepo of interdependent TypeScript packages built with Bazel under pnpm, organized around three extensibility primitives: the Builder pattern (typed build tasks scheduled through a formal job system with state machines and channels), the Schematic pattern (declarative, transactional file-tree transformations for code generation and workspace migrations), and a virtual-filesystem host abstraction that decouples the entire toolchain from real I/O. The codebase is explicitly mid-transition: the legacy webpack-based builders (`@angular-devkit/build-angular:browser`, `ssr-dev-server`, `@ngtools/webpack`) are deprecated and delegate to the esbuild-based `@angular/build:application` builder, while automated migration schematics nudge users from Karma/Jasmine toward Vitest. Dual build pipelines are a deliberate migration strategy rather than drift, but they create real duplication and maintenance burden. Quality is high. Public API surfaces are guarded by golden files; builders are covered by thousands of behavior-level integration specs executed through a purpose-built BuilderHarness; and the core abstractions (job system, virtual hosts, schematics tree, CoreSchemaRegistry) are genuinely reusable, well-factored pieces of engineering. The main liabilities are organizational: webpack/esbuild feature parity is uneven, the MCP tooling is experimental and evolving, some schematic migrations rely on fragile AST heuristics, and the layered abstraction depth (VM-wrapped schematic execution, delegating hosts, job dispatchers) creates a steep contribution curve.
Parcel is a zero-configuration web application bundler designed for speed and simplicity. In production, it parses entry points (HTML, JS, CSS, etc.), resolves dependencies via a plugin system, transforms assets using Rust-based processors (SWC for JS, Lightning CSS for CSS, custom HTML/SVG), optimizes and minifies output, and writes bundles with content hashing. It supports code splitting, tree shaking, CSS modules, TypeScript, and multiple output formats (ESM, CommonJS, global). The architecture is a monorepo with a core orchestrator (`@parcel/core`) that coordinates a pipeline of plugins (transformers, resolvers, packagers, optimizers, compressors, reporters). Performance-critical work is offloaded to Rust crates (e.g., JS transformer, resolver, image optimization) exposed via NAPI bindings. Key entry points include the CLI (`parcel serve`/`watch`/`build`), the `Parcel` API, and the dev server with HMR. The data flow is request-driven: entry resolution → asset graph construction → transformation → bundling → packaging → writing. Parcel relies on Node.js, SWC, Lightning CSS, and various language-specific libraries (PostCSS, Babel, etc.). It is a production-grade tool used by thousands of projects and is actively maintained with frequent releases.
esbuild is a JavaScript/TypeScript/CSS bundler and minifier written in Go. It provides both a CLI and programmatic API for bundling web assets with features like tree shaking, minification, source maps, code splitting, and a development server. The architecture follows a layered design: CLI/API → parsing → dependency resolution → bundling → transformation → code generation. The tool is known for its exceptional performance, achieved through aggressive optimizations, parallel processing, and avoidance of unnecessary caching. It supports modern JavaScript/TypeScript features while being able to target older browsers through syntax lowering.
This is callstack/repack, a monorepo providing a toolkit to replace Metro with Webpack or Rspack for React Native bundling. It delivers a production-grade build pipeline with CLI commands (`start`, `bundle`), a custom Fastify-based dev server with HMR, symbolication, and WebSocket messaging, and over 20 Webpack/Rspack plugins for code splitting, Module Federation (V1/V2), Hermes bytecode compilation, code signing, and asset handling. The architecture is modular: a core `packages/repack` package contains loaders (assets, babel-swc, flow, react-refresh), runtime modules (ScriptManager, Federated helpers), and native Android/iOS code for script loading and code signing. A separate `packages/dev-server` package provides a bundler-agnostic server with delegate interfaces, and first-party plugins for NativeWind, Reanimated, and Expo modules are maintained alongside. The project supports both Webpack 5 and Rspack 1.x/2.x, with extensive integration tests and Metro-compatibility resolver tests. Module Federation is a key feature, enabling micro-frontend architectures in React Native apps with dynamic script loading via the client-side ScriptManager. The codebase is actively maintained with frequent releases, dependency updates, and a well-structured monorepo using pnpm, Turborepo, and Changesets. It demonstrates high craftsmanship in its plugin architecture, WebSocket server design, and source map symbolication, though dual bundler support and multiple Federation plugin versions add some complexity.
Rslib is a library development tool built on top of Rsbuild (which uses Rspack). It provides a CLI and JavaScript API to build JavaScript/TypeScript libraries in multiple output formats: ESM, CJS, UMD, IIFE, and Module Federation. It supports both bundle and bundleless modes, TypeScript declaration generation via three backends (TypeScript Compiler API, tsgo, and isolatedDeclarations), CSS processing with preprocessors and modules, static assets (including SVGR), WebAssembly, Web Workers, and Node.js single-executable applications (SEA). The architecture is plugin-based, leveraging Rsbuild's plugin system and Rspack's compilation pipeline. Key entry points include the CLI commands (`rslib build`, `rslib inspect`, `rslib mf-dev`) and the programmatic API (`createRslib`, `defineConfig`). External dependencies include Rsbuild, Rspack, SWC, Lightning CSS, TypeScript, API Extractor, and the Module Federation plugin. The monorepo contains three published packages: `@rslib/core` (core build engine), `create-rslib` (project scaffolding), and `rsbuild-plugin-dts` (declaration bundling). It includes extensive integration tests with snapshot assertions, e2e tests with Playwright, and a bilingual documentation website. The tool is designed for library authors who need multi-format builds, type declarations, and compatibility with various frameworks (React, Vue, Svelte, Solid). It is part of the Rstack ecosystem alongside Rspress, Rsdoctor, Rstest, and Rslint. Data flows: User configuration (rslib.config.ts) is parsed and merged with defaults, then passed to Rsbuild to generate Rspack configurations per output format. The build process compiles source files with SWC, extracts CSS, generates declarations, and produces final bundles. In bundleless mode, files are emitted individually with import path rewriting. The tool also supports development servers for Module Federation and watch mode for incremental builds.
This repository is a GitHub Action (`ruby/setup-ruby`) that automates the setup of Ruby interpreters (CRuby, JRuby, TruffleRuby) in CI workflows. It downloads prebuilt binaries from official builders (ruby-builder, RubyInstaller2), adds them to PATH, and optionally configures RubyGems and Bundler with intelligent version resolution. A key feature is built-in caching of `bundle install` results via a sophisticated key scheme that accounts for OS, Ruby version, Bundler configuration, and gemfile lock hash. The action supports reading Ruby version from `.ruby-version`, `.tool-versions`, or `mise.toml`, and handles Windows toolchains (MSYS2, DevKit, VCPKG/MSVC) for native gem compilation. The architecture is modular (common utilities, Ruby builder, Bundler, RubyGems, Windows-specific code) and the code is well-structured with clear error handling and thorough CI testing across a matrix of 100+ combinations of OS, Ruby versions, and architectures. Maintenance is active with automated version updates via scheduled workflows and a defined release team.
Microbundle is a zero-configuration bundler for small JavaScript/TypeScript libraries, built on top of Rollup. It automatically generates multiple output formats (ESM, CJS, UMD, and a modern ES2017 bundle) from a single source entry, using package.json fields to determine input and output paths. The system reads the package.json, resolves entry points, and creates Rollup configurations for each format, applying Babel for transpilation (with custom presets for modern vs legacy targets), TypeScript via rollup-plugin-typescript2, CSS handling via PostCSS, and minification via Terser. It supports features like JSX, CSS Modules, property mangling, build-time constant replacement, module aliasing, Web Workers, and bundle visualization. The architecture is a CLI tool (`src/cli.js`) that parses arguments with `sade` and calls the core `microbundle()` function (`src/index.js`), which orchestrates the build pipeline. The codebase is well-structured, with reusable utility modules for option normalization, Babel plugin customization, and size reporting. While the dependency versions are somewhat dated (Rollup 2, Babel 7.12), the project remains actively maintained with recent commits and a comprehensive test suite covering many edge cases.
ncc (Node.js Compiler Collection) is a CLI tool and programmatic library that compiles a Node.js module along with all its dependencies into a single file, similar to gcc for C. It uses Webpack internally with custom loaders for TypeScript, asset relocation, shebang handling, and more. The output can be minified, source-mapped, and optimized with V8 compile cache. It is designed for serverless environments and npm package publishing. The codebase is well-structured with a clear separation between CLI (src/cli.js) and core API (src/index.js). It includes extensive integration tests covering dozens of popular npm packages (Express, React, Apollo, etc.). While the core logic is tightly coupled to Webpack, several utility functions are independently reusable.
html-bundler-webpack-plugin is a webpack plugin that processes HTML templates and bundles associated assets (CSS, JS, images, etc.) into output HTML files. It treats HTML as a webpack entry point, resolves dependencies via webpack's module system, and updates asset references to hashed output URLs. The plugin supports multiple template engines (Pug, Handlebars, EJS, Nunjucks, etc.), asset inlining, subresource integrity, hot module replacement, and code splitting. Architecture consists of a main plugin class, loader infrastructure, and modular preprocessors. It integrates with webpack's compilation hooks for asset extraction and HTML modification. Examples demonstrate usage with frameworks like React, Vue, and CSS tools like TailwindCSS.
mdx-bundler is a JavaScript/TypeScript library that compiles and bundles MDX (Markdown + JSX) content into a single evaluable JavaScript string. It uses esbuild for fast bundling and MDX v3 for compilation. The library allows users to provide MDX source code along with any dependency files (local, remote, or in-memory) and returns a bundled code string, parsed frontmatter, and errors. The bundled code can then be rendered in the browser using a client-side helper (`getMDXComponent`) that supports multiple JSX runtimes (React, Preact, Vue, Hono, etc.). It supports custom remark/rehype plugins, image bundling, global externals for dependency sharing, and flexible esbuild configuration. The architecture is centered around a single async function `bundleMDX` that orchestrates gray-matter parsing, esbuild with an in-memory file plugin, and MDX compilation. The client-side functions are minimal wrappers around `new Function` evaluation. The repository includes comprehensive tests for React, Preact, Vue, and Hono runtimes, and follows semantic release practices.