Open-source alternatives to Metro

Haul is a mobile application development tool that functions as a JavaScript module bundler, TypeScript transpiler, and development server for mobile environments. It provides a command line interface to manage the build pipeline and serve application bundles to connected devices. The tool utilizes Webpack to compile and package JavaScript and TypeScript code specifically for React Native development. It distinguishes itself through a specialized build pipeline that transforms type-safe code into compatible JavaScript for mobile runtimes. The platform covers comprehensive build and tooling c

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

The browserify-handbook is a comprehensive documentation guide for Browserify, a CommonJS module bundler and JavaScript build tool. It explains how to compile Node.js style modules into single JavaScript files for execution within web browsers. The guide covers the generation of universal module definition bundles that function across Node, AMD, and browser environments. It also details the use of browser-compatible polyfills for Node.js built-in modules to ensure cross-platform compatibility. The manual describes capabilities for source code transformation, frontend build automation, and we

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

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.

Optimize-js is a JavaScript parsing optimizer designed to reduce the time browsers spend pre-parsing scripts to improve initial execution speed. It transforms source code to minimize the overhead associated with browser parsing. The project implements a technique that wraps function calls in parentheses to bypass initial pre-parsing and reduce double-parsing overhead. To maintain the utility of the transformed code, it includes a source map generator that links the optimized output back to the original source. The toolset also includes performance benchmarking capabilities to measure the exa

eslint-plugin-import is an ESLint static analysis plugin that provides a suite of rules and resolvers to validate import statements and enforce architectural constraints on how files import and export code. It functions as a module validator and resolver to ensure that import declarations point to valid files and that referenced symbols exist. The project identifies recursive import chains to prevent circular dependencies and utilizes a configurable resolution system to map aliases and non-standard file paths. It can also distinguish between internal project files and external library depende

magic-string is a low-level JavaScript library designed for compilers and bundlers to perform source code transformations. It serves as a string transformation utility and source map manipulation library that allows for modifying text while automatically tracking character offsets. The library enables the modification of source code strings through insertions, replacements, and removals without losing the relationship to original source positions. It specifically provides mechanisms to generate mapping files that link transformed output text back to original source file coordinates. Capabili

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

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

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,

Traceur is a JavaScript syntax transpiler that transforms modern and next-generation language features into compatible versions for older runtime environments. It functions as a compiler that translates proposed language standards and upcoming syntax into current versions to maintain cross-engine compatibility. The project operates as an asynchronous code transformer, converting async functions and generators into promise-based state machines. It includes a functional tail-call optimizer that wraps recursive functions in trampolines to prevent stack overflows and an ECMAScript polyfill engine

Browserify is a build utility that enables the use of CommonJS module patterns within client-side JavaScript applications. It functions as a dependency manager and module bundler, tracing recursive import calls to package multiple source files and their dependencies into a single, optimized file for execution in web browser environments. The project distinguishes itself by providing a comprehensive compatibility layer that allows server-side code to run in the browser. It achieves this by injecting environment shims and replacing system-level globals with browser-compatible equivalents. Throu

Connect-assets is a Node.js asset pipeline and frontend build tool designed to manage the compilation, minification, and serving of scripts and stylesheets. It functions as a static asset bundler that resolves dependency graphs to concatenate source files into optimized bundles, reducing the number of network requests required for page delivery. The tool distinguishes itself by integrating directly into the development lifecycle through middleware that intercepts HTTP requests to compile and serve assets on demand. For production environments, it provides a command-line interface to precompil

Metalsmith is a Node.js static site generator and static content processor that transforms source files into websites, eBooks, or technical documentation. It functions as a file-to-object transformer, converting directory trees into plain JavaScript objects that can be programmatically manipulated in memory. The project is built around a pluggable build pipeline where files are passed through a sequence of custom functions to transform content and metadata incrementally. This architecture allows users to extend functionality by writing their own plugins or using third-party modules to define

TeaVM is a Java bytecode transpiler and browser-based JVM runtime that converts compiled Java class files into JavaScript or WebAssembly. It functions as a compiler and build pipeline tool that enables applications written in various JVM languages to execute natively within a web browser. The project distinguishes itself by transforming bytecode directly into optimized web formats without requiring the original source code. It includes a WebAssembly bytecode compiler for high-performance execution and a specialized emulation system to handle asynchronous multithreading within the single-threa

Nuitka is a compilation framework that translates Python source code into C, enabling the creation of standalone machine code binaries. By converting interpreted scripts into compiled executables, it removes the requirement for a language interpreter on the target machine and provides a mechanism for distributing Python applications as self-contained packages. The project distinguishes itself through advanced optimization techniques, including link-time code generation and profile-guided binary optimization, which improve execution speed by bypassing standard interpreted overhead. It manages

This project is a cross-platform development framework and application boilerplate designed to build mobile, desktop, and web applications from a single shared codebase. It functions as a React Native development tool, utilizing declarative components to render platform-specific user interfaces while maintaining consistent business logic across all supported environments. The framework distinguishes itself by centralizing core application rules and data management, ensuring identical functional results regardless of the target device. It employs a build-time file resolution system that allows

Splittable is a build-time utility designed to transform JavaScript source code into optimized production assets. It functions as a module bundler that maps dependency relationships to combine multiple source files into a unified output, ensuring compatibility across web browsers. The tool distinguishes itself through automated code splitting and dependency analysis, which divide applications into smaller, independent chunks. By identifying shared logic across entry points and isolating common modules, it prevents code duplication and enables asynchronous loading of application logic on deman

Closure Compiler is a JavaScript build utility designed to transform, optimize, and validate source code for production environments. It functions as a minifier and transpiler, converting modern ECMAScript syntax into older, widely compatible versions to ensure reliable execution across diverse browsers. The tool distinguishes itself through a multi-pass optimization pipeline that performs complex refactoring, such as constant folding, function inlining, and variable renaming. It utilizes a static type inference engine to detect potential runtime errors and enforce type safety without requiri

Myth is a CSS build tool and preprocessor that transforms modern styling specifications and future syntax into compatible code for current web browsers. It functions as a polyfill tool, converting advanced features into standard CSS to ensure consistent cross-browser rendering. The project provides automated vendor prefixing based on browser support data and resolves CSS variables into static values for legacy browser compatibility. It also handles the transpilation of custom media query aliases and the manipulation of advanced color functions into standard formats. The toolset includes a co

Haul is a Webpack-based mobile bundler and build tool designed for React Native applications. It manages the development lifecycle and packages source code and assets into bundles for both local development servers and production environments. The project functions as a Webpack bundler extension, allowing the integration of custom loaders and plugins to modify how mobile assets and source code are processed. It includes a mobile bundle analyzer to examine the composition and size of the final output for asset optimization. The toolset covers application build tooling, project configuration a

SystemJS is a dynamic dependency manager and universal module loader that resolves and executes JavaScript modules across different browser and server environments. It functions as an import map polyfill, mapping bare module specifiers to absolute URLs to manage dependencies without requiring a build step. The project provides a system for integrating diverse formats, including AMD and global scripts, into a modern ES module workflow. It enables browser module polyfilling for environments that lack native support for ES modules and import maps, and it allows for dynamic runtime hot-reloading

Pepperoni App Kit is a starter kit and project template for building cross-platform mobile applications for iOS and Android using React Native. It provides a pre-configured scaffold that establishes a modular architecture and shared codebase to bootstrap new projects. The kit integrates a predictable state management system with disk persistence for offline access and a controlled loop for coordinating asynchronous side effects and API interactions. It also includes built-in mechanisms for token-based session authentication and identity validation to maintain secure user logins. The project

Blendid is a Gulp-based static site generator and asset pipeline designed to transform source files into finished websites. It functions as a system for rendering HTML documents by injecting structured configuration data into templates and managing the automated build pipelines required for production delivery. The project provides a configurable asset pipeline that bundles and minifies JavaScript with environment-specific options and source maps. It includes a compiler that transforms Sass and PostCSS files into minified, vendor-prefixed CSS stylesheets. The build automation surface covers

esm is an ECMAScript module loader and JavaScript module path resolver. It functions as a runtime system that executes standard JavaScript modules without requiring a separate build or bundling process. The project provides a compatibility bridge for CommonJS interoperability, wrapping CommonJS exports into synthetic modules to allow imports and exports between different module systems. It includes a dynamic module cache that stores resolved instances in memory to prevent redundant file system reads and repeated execution. The system handles runtime path resolution and file extension detecti

webpack-dev-server is a local web server designed to serve webpack bundles and trigger browser refreshes when source files change. It functions as a development environment that hosts bundled applications and provides a live reloading workflow. The project distinguishes itself by supporting hot module replacement to update modules in a running application without a full page reload. It also acts as an HTTP proxy to redirect network request paths to different backends and provides history API fallbacks specifically for hosting single-page applications. The server includes capabilities for mon