farm-fe/farm

Features

• Web Application Bundlers - Provides an extremely fast Rust-based web build tool that compiles JavaScript, TypeScript, CSS, and HTML into optimized bundles.
• Web Asset Compilation Engines - Compiles and bundles web assets using a Rust core for near-instant builds and sub-20ms hot module replacement.
• Development Servers - Starts a local HTTP server with live reload and hot module replacement for rapid iteration during development.
• Build-Time Processors - Handles CSS, CSS Modules, HTML, images, and other static files with built-in support during the build pipeline.
• Build Result Caches - Stores compiled results on disk so subsequent builds skip recompilation and finish faster.
• Build Pipeline Plugins - Extends the build pipeline with Rust or JavaScript plugins, including Vite plugins, for custom transformations.
• Rollup-Compatible Plugin Integrations - Accepts Vite, Rollup, and Unplugin plugins directly in the build pipeline without modification.
• Rust-Based Web Builders - Builds and bundles web applications with a Rust-based engine for fast compilation and hot module replacement.
• Bundle Splitting - Splits a project into a few optimized bundles to balance load speed and caching granularity.
• Incremental Build Caches - Reuses cached module results across builds so unchanged modules compile only once.
• Sass Compilers - Transforms Sass stylesheets into standard CSS during the build process using a Rust-based compiler.
• Multi-Format Compilers - Compiles HTML, CSS, JavaScript, TypeScript, JSON, and static assets using official plugins for Sass, Less, PostCSS, Vue, React, and Solid.
• SWC Compilers - Transpiles JavaScript, TypeScript, JSX, and TSX files using the SWC compiler with sensible defaults.
• Dead Code Elimination - Removes unused modules and code from the final bundle to reduce output size.
• Hot Module Replacement - Applies code changes to running applications in under 20ms for most updates.
• JavaScript and TypeScript Build Systems - Transpiles JS, TS, JSX, and TSX files into optimized output using Rust-based compilation.
• Module Transformation Pipelines - Transforms module content like Sass to CSS through plugin-based loaders during the build pipeline.
• Hot Module Replacement - Responds to file changes by recompiling affected modules and updating the module graph for live reload.
• Build Output Configurations - Configures entry points and output directories for the build process.
• Module Bundling - Groups modules into output resource pots based on dynamic imports and module graph analysis.
• Production Asset Optimizations - Compiles and optimizes web assets for deployment with tree shaking, minification, and legacy browser support.
• Production Builds - Applies tree shaking, minification, and legacy browser transpilation to produce optimized production output.
• Environment-Consistent Builds - Uses the same bundling process in both development and production, eliminating bugs caused by differing build tools.
• Lazy Module Compilation - Defers compilation of dynamically imported modules until first execution, reducing initial build time.
• Production Build Modes - Applies tree shaking, minification, and legacy browser transpilation for production builds.
• Module Dependency Graphs - Resolves dependencies into a module graph and groups them into optimized resource pots for balanced loading.
• Graph Optimizations - Performs tree shaking and minification on the resolved module dependency graph before code generation.
• Build Output Generators - Farm produces the output files and optional source maps from rendered resource pots.
• Persistent Module Caches - Stores compiled module results on disk and reuses them across builds, skipping recompilation until source changes.
• Plugin Ecosystem Adapters - Accepts Vite, Rollup, and Unplugin plugins directly, enabling reuse of the existing ecosystem without modification.
• Vite-Compatible Bundlers - Supports Vite and Rollup plugins directly, enabling reuse of the existing frontend tooling ecosystem.
• First-Class Module Handlers - Treats CSS, HTML, images, and preprocessor files as first-class modules without JavaScript transformation.
• Module Dependency Analysis - Discovers and registers module import dependencies to fully resolve the build dependency graph.
• CSS Preprocessors - Compiles Sass, Less, and PostCSS stylesheets by adding the corresponding official plugin to the build configuration.
• CSS Modules - Compiles .module.css, .module.scss, and .module.less files as locally scoped CSS modules without extra configuration.
• High-Performance - Provides a local dev server with sub-millisecond hot module replacement and instant startup for rapid iteration.
• First-Class Web Asset Modules - Treats HTML, JS/TS, CSS, and images as first-class modules without requiring transformation to JavaScript.
• Zero-Config Asset Compilation - Handles JS/TS/JSX/TSX, CSS, CSS Modules, Sass, Less, PostCSS, HTML, and static assets without extra configuration.
• Instant Dev Server Startup - Starts a React or Vue project in milliseconds using a Rust-based engine, enabling near-instant HMR updates.
• Millisecond Startup Times - Farm starts a web project in milliseconds and applies updates within 10ms for most changes.
• HTML Entry Point Generators - Transforms HTML files into production builds by resolving and compiling referenced scripts and stylesheets.
• JSX Compilers - Transforms JSX syntax into standard JavaScript during the build process for React applications.
• SWC-Based Transformers - Transpiles JavaScript, TypeScript, JSX, and TSX using SWC with configurable options and plugin integration.
• Multi-Page Entry Point Generation - Compiles multiple HTML entry points in parallel while sharing dependencies across pages.
• Vite Plugins - Accepts existing Vite plugins without modification, enabling reuse of the Vite ecosystem.
• Compiled Script Bundles - Compiles and bundles JavaScript, TypeScript, CSS, HTML, and static assets into deployable files using a Rust-based engine.
• Static Asset Module Importers - Imports non-code files like images or text, emitting them to the output directory as separate files.
• SCSS Compilers - Transpiles Sass and SCSS files into standard CSS during the build process.
• Bundled Code Transformations - Modifies final bundled code of a resource pot, such as replacing placeholder strings before output.
• File-Based Cache Keys - Uses file timestamps or content hashes to skip recompilation of unchanged modules.
• SWC Plugin Integrators - Integrates SWC plugins to transform script modules with configurable options and module filters.
• JavaScript and CSS Minifications - Minifies and mangles JavaScript and CSS files to shrink their size for production.
• Multi-Page Application Builders - Compiles multiple HTML entry points in parallel while sharing dependencies across pages.
• Optimized Bundle Groupings - Combines project output into a small number of bundles to speed loading while keeping cache granularity.
• Less Compilation - Transforms .less files into standard CSS using a JavaScript-based Less compiler.
• Bundle Rendering - Converts a resource pot's modules into bundled code and source maps for final output.
• Debug Instrumentation Stripping - Removes debugger statements and logging calls from production bundles to reduce output size.
• Runtime Plugin Loaders - Ships a runtime plugin system that customizes how modules are loaded and executed in the browser.
• Custom Output Directories - Configures the folder and file naming pattern where built JavaScript, CSS, and static assets are emitted.
• Dependency Auto-Importers - Automatically imports npm packages or React components on demand without manual import statements.
• Glob Pattern Resolvers - Transforms Vite-style import.meta.glob patterns at compile time to import multiple modules matching a file path pattern.
• CLI Config File Readers - Reads project settings from a standard config file in the project root, supporting TypeScript, JavaScript, and ESM formats.
• Asset Path Configurations - Configures a URL prefix applied to all dynamically loaded scripts, styles, and injected HTML tags.
• Multi-Framework Scaffolders - Creates and builds projects for React, Vue, Solid, and vanilla JavaScript with minimal configuration.
• Vanilla JavaScript - Creates new Vanilla JavaScript projects with CLI scaffold and dev server setup.
• Source Map Generators - Generates source maps that map compiled output back to original source files for debugging.
• HTML Layout Inheritance - Provides HTML template inheritance by replacing placeholders in base layouts with child page content.
• TypeScript Declaration Generators - Produces TypeScript declaration files (.d.ts) from source code during the build process.
• Virtual Modules - Provides custom content and type for modules identified by a virtual module id during the build.
• Output File Modifications - Adds or removes output files and modifies resources like HTML to include script and style tags.
• Build Pipeline Hooks - Adds JavaScript-based compilation hooks with configurable priority and module filters to control execution.
• Module Resolution - Overrides how source paths are resolved to module identifiers, enabling virtual modules and custom import behavior.
• Path Aliases and Externalizations - Maps import paths to custom directories with aliases and marks dependencies as external to exclude them from the bundle.
• Build Plugin Systems - Provides a Rust-based plugin system for adding high-performance compilation steps to the build pipeline.
• Scoped Environment Variable Injections - Loads variables from .env files and injects them into the build with support for environment-specific and custom mode files.
• Client-Server Bundle Optimizations - Compiles the application twice, once for the browser and once for Node.js, using separate configuration files for each target.
• AST Transformation Pipelines - Modifies the parsed abstract syntax tree of modules, for example stripping TypeScript annotations.
• Dual-Target Compilation - Compiles output to support both ES5 and modern browsers, ensuring broad compatibility.
• React - Creates new React projects with component library and plugin setup from scratch.
• CSS Vendor Prefix Normalizers - Adds vendor prefixes to CSS rules automatically based on configured browser targets.
• Custom Middleware Development - Intercepts and processes incoming requests by plugging custom middleware into the development server pipeline.
• Build-Time Polyfill Injectors - Downgrades syntax and adds polyfills during the build process so the output runs on older browsers.
• Environment-Based Cache Invalidations - Automatically clears the cache when environment variables, lockfiles, or tool versions change to ensure correctness.
• PostCSS Pipeline Integration - Applies PostCSS transformations to CSS files during the build pipeline.
• PostCSS Plugin Execution - Runs CSS through PostCSS plugins configured in a postcss.config.js file to apply post-processing.
• Server-Side Rendering with Hydration - Renders front-end framework components to HTML in Node.js and hydrates the rendered markup on the client for faster initial loads.
• Middleware Implementations - Provides server-side rendering middleware that replaces placeholders with rendered markup for fast initial loads.
• Static HTML Generators - Emits fully replaced HTML as static files during the build process, enabling pre-rendered pages without a live server.
• Dev Server Behaviors - Opens the browser on startup, sets the server port, and configures hot module replacement behavior.
• SVG Component Transformations - Transforms SVG files into importable React components during the build process.
• Public Directory Servings - Places unprocessed files in a public folder so they are served directly and can be referenced by URL.

Star history