Open-source alternatives to Less.js

UglifyJS2 is a suite of tools designed for parsing, beautifying, mangling, and minifying JavaScript code. It functions by converting source code into an abstract syntax tree to enable programmatic analysis and transformation, and it includes a dedicated generator for creating associated source maps. The project optimizes web production builds by compressing script logic and removing unreachable code. It utilizes name mangling to shorten variable and property names and implements a beautifier to reconstruct compressed scripts into a human-readable layout. The toolset covers broad capability a

Snowpack is an ESM-powered frontend build tool and development server that serves native ES modules directly to the browser. By eliminating the bundling process during development, it enables nearly instant server startup and unbundled frontend development. The project features a framework-aware hot module reload system that preserves component state during updates, with specific Fast Refresh integration for React, Preact, Svelte, and Vue. It also acts as a modern web transpiler, automatically converting TypeScript, JSX, and CSS Modules into browser-compatible code without requiring manual co

sqlglot is a SQL parser and transpiler that represents queries as abstract syntax trees to enable structural analysis, modification, and semantic transformation. It functions as a dialect translator and query optimizer, converting SQL code between different database engines and simplifying syntax trees through rule-based normalization. The project provides a framework for defining custom SQL dialects by overriding tokenizers, parsers, and generators. It includes a lineage analyzer to track data flow from source tables through complex queries to identify the origin of specific columns. Additi

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

This project is a comprehensive manual and educational resource focused on the Babel compiler. It serves as a documentation guide and handbook for understanding the inner workings of JavaScript compilation, specifically regarding the transformation of source code. The material provides a technical walkthrough for developing custom plugins and extensions. It covers the process of creating tailored transformations to modify how JavaScript is parsed and generated. The content encompasses the broader JavaScript compilation workflow, focusing on abstract syntax tree manipulation, code generation,

Farm is a Rust-based web build tool and development server that compiles JavaScript, TypeScript, CSS, HTML, and static assets into optimized bundles. It uses a module-graph-based bundling approach with persistent module-level caching, enabling near-instant builds and sub-20ms hot module replacement during development. The tool processes assets based on file extensions, handling CSS, Sass, Less, PostCSS, HTML, and images as first-class modules without requiring JavaScript transformation. Farm distinguishes itself through its Vite-compatible plugin system, accepting Vite, Rollup, and Unplugin p

UglifyJS is a tool for JavaScript code minification, AST manipulation, and source beautification. Its primary purpose is to reduce the file size of JavaScript source code by removing whitespace and shortening variable names to optimize frontend build assets. The project differentiates itself through its ability to programmatically analyze and transform code using abstract syntax trees. It performs constant folding analysis and conditional compilation to eliminate unreachable or redundant code, and it employs a multi-pass compression pipeline to maximize total file size reduction. The tool pr

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,

preact-cli is a command line tool for scaffolding, developing, and building applications using the Preact library. It provides a Webpack-based build pipeline to coordinate code transformation, asset optimization, and production compilation. The toolkit includes a static site prerenderer to convert application routes into static HTML files and a PWA development toolkit for generating service workers and offline asset caching. It also functions as a frontend development server featuring hot module replacement and a proxy for real-time application iteration. The project covers a broad range of

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

This project is a command-line tool and build toolchain used to bootstrap React web applications. It serves as a project bootstrapper and single-page application scaffold, providing a pre-configured development environment, folder structure, and build pipeline. The toolchain integrates a frontend development server with live reloading and error overlays to accelerate the iterative coding process. It handles production asset bundling by minifying code and generating hashed assets for deployment, and it includes a configuration suite for generating the service workers and web manifests required

js-yaml is a JavaScript library providing a programmatic interface for parsing and dumping YAML data. It functions as a parser and serializer that converts YAML strings into JavaScript objects and transforms JavaScript objects back into YAML format. The library includes a command-line interface for parsing or dumping YAML data via direct input or data pipes. It also features an abstract syntax tree transformer to modify the structure of data during serialization. The project provides capabilities for multi-document processing and the definition of custom schemas and tags to handle specialize

Brunch is a frontend build tool and JavaScript asset bundler designed to automate the transformation of source code into production-ready assets. It functions as an incremental build system that monitors the filesystem for changes to rebuild only modified components, and it serves as a project scaffolding engine for initializing application structures via predefined skeletons and code boilerplates. The tool utilizes a plugin-based transformation pipeline to compile and optimize JavaScript and CSS files for browser delivery. It distinguishes itself through the use of multi-core build paralleli

Rspack is a high-performance web bundler written in Rust that packages JavaScript and TypeScript for web applications. It functions as an incremental build engine and a tree-shaking asset optimizer designed to reduce build times and minimize final bundle sizes for web delivery. The project is built for compatibility with the webpack ecosystem, implementing a compatible API that allows existing plugins and configurations to work without modification. This enables the integration of community loaders and plugins while leveraging a Rust-based compilation engine. The tool covers a broad range of

esbuild is a high-performance JavaScript bundler and transpiler designed to transform modern web assets into production-ready code. Built with a focus on speed, it utilizes a concurrent execution model to perform parsing, linking, and code generation across multiple CPU cores. The engine handles a wide range of tasks, including TypeScript compilation, JSX transformation, and CSS bundling, while maintaining a consistent build process across diverse environments. What distinguishes the project is its architecture, which leverages memory-mapped file processing and a single-pass transformation st

Koala is a graphical user interface for managing the compilation, transpilation, and background monitoring of web asset preprocessors. It serves as a build tool that converts Less, Sass, and CoffeeScript files into browser-compatible CSS and JavaScript. The application features a visual interface for controlling the transformation process, removing the need for command line interaction. It integrates a background file monitor that automatically recompiles source files in real time as changes are detected on the local filesystem. The tool provides utilities for managing global and project-spe

This project is a CSS stylesheet compiler that transforms Sass source code into standard CSS. It provides the primary mechanism for converting styles while implementing syntax rules for web browsers and applications. The compiler supports a module-based dependency system that uses dedicated namespaces to provide encapsulation and prevent global scope collisions. It includes specialized engines for multi-model color conversion and advanced mathematical calculations, including trigonometry and logarithms. Capabilities cover a broad range of build and analysis tools, including the generation of

LibSass is a high-performance Sass to CSS compiler implemented as a native C++ engine. It transforms style sheets written in a pre-processor language into standard CSS. The project provides a C language application binary interface that allows the compilation engine to be embedded into different programming languages. It features a modular architecture that supports extending compilation logic through a shared-library plugin system. The engine handles style sheet resolution and uses a multi-stage process to parse source text into an abstract syntax tree before emitting the final CSS output.

env is a Go library that reads environment variables and populates the fields of a Go struct according to tag directives. It uses reflection to iterate over struct types and tags at runtime, mapping environment variable names to struct fields and applying parsing behavior defined in struct tags. The library supports required field validation, returning errors when marked fields are missing or empty after parsing. It also provides default value fallback from struct tags when environment variables are not set, environment variable expansion that recursively substitutes references within values,

Expr is a high-performance expression evaluation engine and language for Go applications. It functions as a dynamic rule engine that parses and executes custom logic and data validations at runtime without requiring the application to be recompiled. The system utilizes a sandboxed logic executor to run expressions without side effects. It ensures program termination by employing instruction-level loop detection to prevent infinite loops and isolates the evaluation process from the host system. The engine employs a bytecode-based virtual machine and abstract syntax tree analysis to achieve ex

jscodeshift is a JavaScript AST transformation toolkit and codemod engine designed for large-scale code refactoring and structural migrations. It provides a set of utilities to parse source code into abstract syntax trees, programmatically modify those trees, and convert them back into source text. The tool distinguishes itself by preserving original source formatting and stylistic properties during the transformation process. It utilizes a builder for generating structurally valid AST nodes and integrates interchangeable parsing engines to support different language standards and experimenta

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.

This project is a CSS layout framework that functions as a responsive UI geometry solver. It replaces traditional static box model calculations with a constraint-based engine that determines element positions and dimensions by evaluating relational rules. The engine distinguishes itself by using a system of linear equations to resolve geometric conflicts, ensuring that all spatial constraints are satisfied simultaneously. It utilizes a shorthand visual syntax to define these relationships, allowing developers to describe complex alignment and spacing requirements through a declarative languag

cel-go is a Go implementation of the Common Expression Language, providing a type-safe engine for the evaluation of non-Turing complete, side-effect-free expressions. It functions as an embedded expression engine that converts human-readable strings into type-checked abstract syntax trees to ensure safe execution. The system utilizes a compile-once evaluate-many model, parsing and validating expressions into cached programs for repeated execution across different datasets. It further distinguishes itself as a partial state evaluator, using commutative logic to compute results and return resid

QLExpress is a dynamic scripting engine and expression language for the Java platform. It functions as a runtime expression evaluator and business rule engine, allowing applications to execute scripts and evaluate business logic without requiring system recompilation. The engine distinguishes itself through a secure scripting sandbox that enforces security policies via class whitelisting and execution timeouts. It supports high-precision mathematics to prevent rounding errors and provides language alias support to create domain-specific languages that resemble natural language. Additional cap

Hugo is a high-performance static site generator that transforms source content and templates into optimized web assets. Built with a focus on speed and scalability, it provides a comprehensive framework for managing large-scale documentation and editorial projects through structured content organization, taxonomies, and a flexible template-driven rendering engine. The project distinguishes itself through a sophisticated build system that utilizes incremental caching to minimize redundant processing during site updates. It supports complex content requirements by enabling multidimensional mod

This project is a self-hosted community engine and forum software designed for hosting threaded discussions. It functions as a JSON API community platform, exposing all data and functionality through a standardized interface to support a single-page application architecture. The system is built to be a multi-language discussion board with integrated localization and language pack support. The platform is defined by a modular architecture that allows for extensive customization through an extension-based plugin system. This extensibility enables the modification of core behavior, the addition