Open-source alternatives to Gulp

Task is a YAML-based task runner and build tool used to define and automate development workflows. It functions as a dependency-based build system and cross-platform task automator, allowing users to execute shell commands across different operating systems using a declarative configuration file. The project operates as an incremental build tool, utilizing file fingerprints and checksums to track state and avoid redundant work by determining if tasks are up to date. It manages execution via a dependency graph to ensure prerequisites are completed before target commands run. The system includ

This project is a build orchestration engine and development toolkit designed for managing large-scale monorepos. It provides a unified workspace environment that maps project relationships and dependencies, enabling the system to perform intelligent impact analysis and execute only the tasks affected by specific code changes. The system distinguishes itself through a persistent daemon that monitors file changes for near-instant feedback and a content-addressable caching mechanism that stores task outputs to prevent redundant computation across local and remote environments. It further suppor

Vite is a frontend build toolchain that provides a unified development and production pipeline for modern web applications. It functions as a modular, environment-agnostic build engine that leverages native ES modules to serve source code directly to the browser, eliminating the need for expensive bundling during the development phase. By maintaining an environment-aware module graph, it supports concurrent development across client, server, and custom runtime environments. The project distinguishes itself through a high-performance development server that utilizes a hot module replacement pr

Parcel is a web application bundler designed to automate the packaging of project assets for production. It functions as a zero-configuration tool that detects dependencies and transforms source files into optimized output without requiring manual setup files. The project includes a built-in development server that supports incremental builds and hot module replacement to reflect code changes during the development cycle. The core of the system is a dependency graph resolver that maps relationships between modules to determine the structure of output bundles. This is supported by a modular as

Webpack is a module bundler that maps project dependencies into a directed acyclic graph to transform diverse file types into optimized, browser-ready assets. It functions as a build pipeline orchestrator, using entry points to recursively resolve imports and bundle modules, scripts, and static assets into a unified output. The project is distinguished by its plugin-based architecture and loader-driven transformation pipeline. It utilizes an event-driven hook system that allows developers to intercept and modify the build process at specific lifecycle stages, enabling custom code transformati

Guard is a command-line file watcher that monitors the filesystem from the terminal and automatically executes user-defined tasks when files are modified, added, or deleted. It functions as a file change watcher and test runner that triggers test suite execution immediately when source or spec files are saved, providing instant feedback during development. The tool is configured through a Ruby-based domain-specific language in a Guardfile, and it can send visual desktop notifications when watched file actions complete or fail. The project distinguishes itself through a plugin-based extension

entr is a command-line tool and shell command orchestrator that executes arbitrary terminal commands automatically whenever monitored files are modified. It serves as a Unix file system monitor that maps filesystem events to the execution of user-defined shell commands. The utility functions as a development workflow automator by restarting background processes and refreshing console output to provide immediate feedback during coding. It can terminate and restart long-running services when configuration or source code is updated. The project covers automated task execution and continuous int

Assemble is a static site generator and build pipeline system that compiles markdown, templates, and data into static HTML files. It functions as a markdown-to-HTML converter and a data format transformer capable of moving content between JSON, YAML, XML, PLIST, and CSV formats. The project features a pipeline-based build process where users can define ordered sequences of data transformations and file processing steps. It includes project scaffolding tools to bootstrap directory structures and configuration files from predefined boilerplates. The system manages content through collection-ba

fswatch is a cross-platform file change monitor and event automation tool. It tracks file system modifications across different operating systems using native kernel event APIs or a portable polling fallback. The project implements specific wrappers for Linux systems using inotify and fanotify, as well as a watcher for BSD and macOS using kqueue. It translates these platform-specific APIs into a unified event format to provide consistent monitoring behavior. The tool allows for the automatic execution of external programs or scripts in response to detected changes. It includes capabilities f

Earthly is a containerized build system and Docker build framework designed for creating reproducible build pipelines. It ensures environment consistency by executing every build step inside an isolated container, combining the isolation of container images with dependency tracking and parallel execution. The system differentiates itself through a focus on hermeticity and multiplatform support, allowing for the generation of container images targeting multiple CPU architectures within a single execution flow. It maintains a hermetic build environment by isolating network access and utilizing

Realize is a development workflow automator, task runner, and live-reloading tool primarily used for Golang application development. It monitors the filesystem for changes to automatically restart running applications and execute predefined sequences of shell commands and environment variables. The system acts as a multi-project task manager, coordinating and tracking automation workflows across several different software projects simultaneously from a single configuration. Its capability surface covers filesystem event monitoring, process lifecycle management for hot-reloading, and the exec

MSBuild is a .NET build engine and software build automation system that transforms source code into deployable applications. It utilizes a declarative project system based on a structured XML schema to define build items, properties, and targets used across the .NET ecosystem and Visual Studio. The system features a customizable build task framework that allows the implementation of custom tasks and loggers to perform specific software construction operations. This extensibility enables the creation of specialized logic to modify build process behavior. The engine manages build automation t

Watchman is a filesystem change monitor and recursive directory watcher that operates as a background service to track file modifications in real time. It functions as an event-driven file trigger and state query engine, allowing users to retrieve directory snapshots and lists of changed files since a previous check. The project provides tooling for incremental builds by identifying exactly which files have changed to compile only necessary project components. It is designed for large scale directory watching, monitoring massive file trees while executing external commands or scripts automati

Mage is a build automation tool and workflow orchestrator that uses Go functions to define executable build targets instead of a custom domain-specific language. It functions as a compiled build system and task runner, mapping exported Go functions to command-line targets. The tool distinguishes itself by compiling build definitions into static binaries for distribution to dependency-free machines. It utilizes hashed binary caching to avoid redundant compilations and supports the packaging of the runtime and defined tasks into a single standalone executable. The platform covers dependency ma

Gaia is a polyglot pipeline orchestrator and continuous integration and delivery automation platform. It functions as a multi-language workflow engine that coordinates the movement and transformation of data by executing tasks written in different programming languages through a dependency graph. The platform distinguishes itself with a visual pipeline configurator for mapping function arguments via a management portal and a secure secret manager that uses ciphers to encrypt passwords and tokens. It further automates the software lifecycle by cloning repositories and recompiling applications

Bazel is a multi-language build automation engine designed to manage complex dependency graphs and execute compilation tasks for massive codebases. It functions as a hermetic build environment, utilizing sandboxed execution and content-addressable caching to ensure that build artifacts are reproducible and that identical tasks are never re-executed. By modeling dependencies as a directed acyclic graph, the system determines optimal execution order and identifies tasks that can run in parallel. The project distinguishes itself through its support for distributed build execution, allowing resou

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

Dagger is a programmable CI/CD engine and containerized task runner designed to orchestrate build and test pipelines. It functions as an incremental build system that manages containers, filesystems, and secrets through a typed API to ensure consistent execution across local and cloud environments. The engine utilizes a language-agnostic client-server API to allow multi-language pipeline orchestration, enabling the sharing of typed artifacts and state across different SDKs without manual serialization. It optimizes execution through content-addressable caching and a directed acyclic graph to

Watchdog is a Python library and set of shell utilities for monitoring filesystem events. It provides a framework for tracking real-time changes to files and directories, mapping those events to configurable automation handlers, and executing system actions based on file creation, modification, or deletion. The project includes an event-driven shell utility for triggering custom scripts and commands automatically. It utilizes a configurable handler framework that allows users to associate specific filesystem events with specialized plugin logic defined in configuration files. The system moni

Turbo is a high-performance build system and monorepo task orchestrator for JavaScript and TypeScript projects. Written in Rust, it serves as a build artifact cache that minimizes redundant work by storing and restoring the outputs of previous tasks. The tool manages complex dependency graphs to coordinate builds and tests across multiple packages in a single repository. It utilizes hash-based change detection and content-addressable caching to determine which tasks require execution and which can be restored from local or remote caches. Its capabilities cover build pipeline acceleration for

Pants is a monorepo build system designed to manage multi-language software projects within a single repository. It functions as a polyglot task runner and distributed build orchestrator, providing a unified interface for executing compilers, linters, and test runners across different programming languages. The system is distinguished by a dependency analysis engine that uses static source code analysis to model software dependencies, removing the need for manual build metadata files. It ensures reproducible builds through hermetic isolation and protects the software supply chain using depend

Nuke is a build automation system for defining software compilation and deployment pipelines using a strongly typed C# console application. It functions as a cross-platform build engine and pipeline orchestrator that treats build configurations as standard executable programs rather than static files. By leveraging a compiled language, the system provides type safety and IDE support for build script logic. This approach allows for the definition of automation and CI/CD pipelines using a professional programming language instead of YAML or shell scripts. The engine manages .NET project orches

This project is a comprehensive front-end development guide and roadmap designed to help engineers master the skills and professional standards required for modern web development. It serves as a technical reference for mastering HTML, CSS, and JavaScript, providing structured learning paths and a map of the professional competencies needed to transition from a beginner to a professional web engineer. The resource functions as a categorized directory and ecosystem overview of the JavaScript landscape. It catalogs industry-standard frameworks, libraries, and utilities, offering specific recomm

fsnotify is a cross-platform filesystem notification library that provides a programming interface for tracking file and directory changes within Go applications. It utilizes native kernel notification interfaces to detect events such as file creation, deletion, and attribute updates, allowing developers to integrate real-time monitoring into their software. The library distinguishes itself by providing a unified abstraction layer that normalizes disparate kernel APIs into a consistent event stream. It manages high-volume activity through non-blocking event polling and internal memory bufferi

This project is a web development boilerplate and starter kit providing a pre-configured foundation for creating high-performance, responsive websites. It functions as a development kit for building progressive web apps, incorporating a front-end build pipeline and responsive site templates. The kit distinguishes itself through a multi-device testing workflow that synchronizes clicks, scrolls, and form inputs across multiple browsers and devices in real-time. It also includes a dedicated setup for offline functionality using service workers and web manifests to enable native-like installation

Backpack is a Node.js build system designed for transpiling, bundling, and automating the development workflow. It functions as a JavaScript asset bundler that packages source files and dependencies into optimized output for production deployment. The system integrates a transpilation process to convert modern code into versions compatible with various environments and browsers. It provides an automated development workflow that watches for file changes to trigger automatic reloads and builds. The build pipeline supports configuration-driven customization, environment-specific targets, and i

ReLaXed is a document workflow and compilation system that transforms Markdown, JSON data, and HTML/CSS into print-ready PDF files. It utilizes a headless browser engine to render web technologies into final documents, serving as a build system for technical documentation and dynamic reports. The project features a pipeline that automates asset generation, allowing scripts to produce images, charts, and tables from raw data files during the build process. It supports the integration of LaTeX formulas for mathematical equations and converts CSV files into formatted HTML tables. The system inc