Open-source alternatives to Webpack Dev Server

live-server is a local HTTP server designed for hosting static HTML, JavaScript, and CSS files. It functions as a live reload development server that monitors file changes and automatically refreshes the browser to reflect updates. The server includes an HTTP request proxy to route specific paths to remote URLs, bypassing cross-origin resource sharing restrictions. It also serves as a single page application routing proxy, mapping URL requests to a specific entry file to support client-side navigation. Additional capabilities cover security and access control through basic authentication and

Caddy is an extensible, modular web server platform designed for high-performance traffic management and automated security. At its core, it functions as a dynamic HTTP gateway that handles request routing, static asset delivery, and reverse proxying through a chain of configurable handler modules. The system is built on a modular architecture that allows developers to extend server functionality by registering custom components, all managed through a unified lifecycle and provisioning framework. What distinguishes Caddy is its focus on automated infrastructure and zero-downtime operations. I

Werkzeug is a comprehensive library and toolkit for building WSGI-compliant web applications in Python. It provides the fundamental building blocks for web development, including an HTTP request and response toolkit, a rule-based URL routing engine, and a library for managing the overall web application lifecycle. The project is distinguished by its integrated development suite, which includes a WSGI development server featuring automatic code reloading and a PIN-protected interactive browser debugger for inspecting call stacks. It also includes a specialized WSGI test client that enables the

This is a header-only C++ library that provides implementations for HTTP clients, HTTP servers, and a WebSocket framework. It allows for the creation of network services and the consumption of remote APIs without requiring a separate compilation step or external binary linking. The project features backend-agnostic TLS integration for secure HTTPS and WSS communication and employs a thread-pool model to process concurrent requests. It distinguishes itself with a full-duplex WebSocket state-machine and a middleware-based request pipeline that supports regular-expression path routing. The libr

This project is a comprehensive sample library and implementation guide for ASP.NET Core. It provides a collection of practical examples and projects that demonstrate how to build web applications, RESTful APIs, and high-performance services. The repository focuses on a variety of architectural patterns, including the development of Minimal APIs, contract-first gRPC services, and real-time communication using WebSockets and Server-Sent Events. It includes detailed implementations for user identity and security, such as token-based authentication and CSRF protection. The codebase covers a bro

RoadRunner is a high-performance application server and process manager designed to serve PHP applications using a persistent worker model. It eliminates bootload overhead and initialization time by keeping application processes alive between requests, acting as a protocol-agnostic proxy that routes traffic to a pool of supervised workers. The server is built with a plugin-based modular architecture, allowing it to be extended with custom Go plugins and compiled into tailored binaries. It distinguishes itself by providing a unified execution model for a wide array of communication protocols,

Rendr is an isomorphic JavaScript framework and server-side renderer designed for Backbone.js applications. It synchronizes view rendering between Node.js servers and client browsers to provide initial HTML for improved search engine indexing and load speeds while maintaining application interactivity. The system uses a pluggable adapter system to decouple rendering logic from specific HTML template engines, allowing developers to swap or integrate custom engines. It also functions as a server-side proxy that intercepts client requests via virtual paths and forwards them to remote RESTful ser

This project is a comprehensive library of reference implementations and patterns for building web applications using the Go Fiber framework. It provides curated templates and implementation guides for creating REST APIs, web servers, and structured backend services. The repository serves as a practical resource for applying architectural patterns, including Clean and Hexagonal architectures, as well as port-and-adapter decoupling. It offers detailed examples for integrating common web features such as OAuth2 authentication, JWT verification, WebSockets for real-time communication, and server

json-server is a development toolset used to simulate a full REST API from a JSON file. It functions as a customizable mock API server that allows for the simulation of CRUD operations and resource relationships without the need to write backend code. The project enables rapid prototyping by generating a fake backend that persists data changes back to a local JSON file. It distinguishes itself by providing a static asset file server to deliver local documents, images, and stylesheets alongside the mock API endpoints. The server includes capabilities for data querying, such as parameter-based

Apache Tomcat is an open-source implementation of the Jakarta Servlet, Pages, Expression Language, and WebSocket specifications, serving as a container for running Java web applications. It provides a modular architecture with a servlet container, connector abstraction for multiple I/O models, and a pipeline-based request processing system that handles cross-cutting concerns through composable components. The server supports container-managed security with configurable realms for authentication against JDBC, LDAP, or memory-based credential stores, and offers TLS encryption with optional Open

mcp-context-forge is a Model Context Protocol federation gateway that unifies diverse AI tool servers and APIs into a single consistent interface for discovery and execution. It acts as a centralized proxy that aggregates multiple servers and APIs, allowing AI agents to access and invoke a unified set of tools, prompts, and resources. The project distinguishes itself through a multi-protocol translation bridge that converts communication between standard I/O, SSE, gRPC, and REST to enable interoperability between disparate tool servers. It includes a comprehensive LLM evaluation framework for

Rushstack is a comprehensive toolset for managing large-scale TypeScript monorepos, providing a framework for build pipeline automation, dependency coordination, and static analysis. It functions as an incremental build orchestrator and management system designed to maintain consistency and performance across multiple packages in a shared workspace. The system distinguishes itself through an execution model based on directed acyclic graphs and content-hash-based incrementalism, which ensures only affected projects are rebuilt. It further optimizes development workflows via remote build artifa

This project is a PHP compatibility library that provides a polyfill for the native ctype extension. It serves as a portability layer, implementing missing core language functions to ensure consistent behavior across different server environments and PHP versions. The library specializes in character type validation, recreating the behavior of native extension functions using pure PHP code. It uses runtime environment detection to identify if the native extension is missing and injects fallback implementations directly into the global namespace to prevent collisions and maintain code portabil

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

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

Middleman is a Ruby-based static site generator and web framework used to transform templates and assets into standalone HTML, CSS, and JavaScript files. It functions as a multi-engine template processor and build tool, converting source markup into production-ready websites that can be hosted on any web server. The system is distinguished by a comprehensive asset pipeline that handles compression, minification, and fingerprinting to optimize web delivery. It features an extensible architecture with lifecycle hooks and a middleware-based request interception layer, allowing for the programmat

This project is a full-stack web framework and starter template designed for building applications that integrate React frontend interfaces with Node.js and Express backend services. It provides a unified development environment that synchronizes both frontend and backend processes, allowing for a cohesive workflow within a single project structure. The framework distinguishes itself by orchestrating the development lifecycle through automated server restarts and live reloading, which eliminates the need for manual refreshes during testing. It includes built-in configurations for transpiling

Highly scalable realtime pub/sub and RPC framework

The Angular Command Line Interface is a tool for initializing, scaffolding, and managing the development lifecycle of Angular web applications from a terminal. It functions as a project manager and frontend build toolchain, providing a standardized way to bootstrap new applications and manage their overall health and configuration. The tool employs schematic-based code generation to create standardized project structures and components. It utilizes a workspace-based configuration to manage multiple related applications and libraries within a single shared root and dependency tree. The system

This project is an Xcode runtime code injector and developer productivity tool. It enables the injection of Swift and Objective-C code changes into a running application without requiring a process restart, functioning as a hot module replacement tool for iOS development. The tool provides a dynamic UI debugger for reloading storyboards and tuning visual parameters in real time. It allows for the recompilation of individual classes and the binding of new implementations into a live process, avoiding full project rebuilds. The system covers runtime injection capabilities, including automated

InjectionIII is a suite of development utilities designed for runtime code reloading, expression evaluation, and automated code injection. It provides a system for recompiling modified source files and patching function pointers in a live process to update application behavior without requiring a full restart. The project utilizes Xcode build script extensions and a live code injector to deliver Swift and Objective-C changes to desktop applications and physical hardware. It features a runtime evaluator that executes string-based Swift expressions to inspect state and retrieve values from a ru

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

ngbp is a web application build system and project bootstrapper designed to automate the initialization and delivery of web projects. It provides a framework for generating standardized directory structures and preconfigured tooling to establish a baseline for scalable applications. The system features a client-side template cache that converts HTML templates into JavaScript strings to reduce network requests. It also includes a development workflow automator that monitors file changes to trigger automatic linting, unit testing, and browser refreshing. The tool covers build orchestration thr

Primus is a real-time communication abstraction layer and middleware framework. It provides a standardized interface for messaging that allows developers to switch between different transport engines without rewriting application logic, while also serving as a wrapper for managing socket lifecycles. The project distinguishes itself by functioning as a real-time client library generator, producing compatible client-side code based on server configurations. It further organizes data flow through virtual stream multiplexing and the ability to group connections into named communication rooms for

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

Trunk is a build tool and development server for compiling Rust code to WebAssembly and packaging it for browser deployment. It functions as a web bundler that combines WebAssembly modules, JavaScript, and static files into a deployable web application. The tool provides a local development server utilizing HTTP and WebSocket proxies to enable rapid iteration. This environment includes a file-system watcher that triggers automatic rebuilds and browser reloading when source files are modified. The pipeline handles the conversion of Rust source code into WebAssembly binaries and generates the

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