This repository implements a comprehensive HTTP server application written in Rust. It serves files from a directory with features including directory listing, authentication, WebDAV support, archive generation (ZIP/TAR), bandwidth limiting, TLS encryption, and response compression. The architecture is monolithic, using the Iron web framework with Hyper for HTTP handling. Key components include modular operation handling (file serving, WebDAV, archiving), command-line option parsing, OS-specific utilities, and intelligent caching mechanisms for encoded content.
Crow is a modern C++ microframework for building HTTP and WebSocket services. Designed as a single-header library (or modular headers), it provides a Flask-like routing system with typed URL parameters, a middleware pipeline (global and per-route), built-in JSON parsing and generation, Mustache templating, multipart form handling, static file serving, gzip/deflate compression, and SSL/TLS support. The framework is header-only and leverages C++17/20 features such as std::string_view, std::optional, and constexpr where possible. It includes a comprehensive test suite (Catch2), fuzz testing for security, and extensive documentation via MkDocs and Doxygen. Crow is packaged for multiple platforms (Vcpkg, Homebrew, AUR, Conan, Nixpkgs) and is used in production by several open-source projects. The architecture is event-driven, built on top of Asio (standalone or Boost), with a focus on performance and simplicity. Reusable components include a standalone JSON library, base64 utilities, and a flexible middleware system.
QRServ is an Android application that turns a device into a local file-sharing server. Users select files (or use Direct Access Mode for single files without copying), and the app starts an embedded Ktor HTTP server on an unused port. The server URL is displayed as a QR code for other devices on the same network to scan and download files. Optionally, on Android 13+, QRServ can create a private Wi-Fi hotspot (with band selection on Android 16+) so that only devices joining the hotspot can access the files. The app runs a foreground service with a persistent notification, handles HTTP range requests for large files, and includes an idle timeout that automatically stops the server when no downloads occur for a configurable period. The architecture follows a standard Android MVVM pattern with Jetpack Compose UI, using StateFlow for reactive state management and a centralized ViewModel (QRServViewModel) that orchestrates server lifecycle, network callbacks, and hotspot control. The codebase demonstrates strong engineering practices including comprehensive unit tests, separation of concerns into repositories and controllers, and careful handling of Android-specific edge cases such as permission revocations, network changes, and file removal during sharing. The app is available on Google Play and IzzyOnDroid with multi-language support.
RoadRunner is a high-performance PHP application server and process manager written in Go. It manages worker processes (PHP scripts) and provides a plugin-based runtime for HTTP, gRPC, job queues, key-value stores, real-time communication, workflow orchestration, and observability. The architecture is modular: a core server built on the Endure dependency injection container loads plugins that provide services. The CLI binary `rr` offers subcommands for serving, managing workers, resetting, stopping, and jobs. Configuration is via YAML (`.rr.yaml`) with environment variable substitution and includes. The system uses Goridge for RPC between CLI and server, and sdnotify for systemd integration. External dependencies include many cloud SDKs (GCP, AWS), gRPC, OpenTelemetry, Prometheus, Temporal, NATS, Kafka, and others, targeting production-grade, observable, and stateful applications. The project is MIT-licensed and maintained by SpiralScout, with CI/CD for cross-platform builds (Linux, macOS, Windows, FreeBSD) and Docker images.
Ratpack is a lightweight, reactive web framework for the JVM built on Netty and Java 8. It provides an asynchronous execution model based on Promise/Operation, a flexible handler chain for request processing, pluggable configuration from multiple sources, and a Registry-based dependency injection system. The framework includes first-class Groovy DSL support, a comprehensive test harness, and integrations with Spring Boot, Google Guice, Dropwizard Metrics, multiple template engines (Handlebars, Thymeleaf, Rocker, Groovy), Redis for session storage, and reactive libraries (RxJava 2, Reactor). The codebase is modular with over 30 subprojects, extensive Spock test coverage, and a Gradle plugin for continuous reloading. While the public API is well-designed and documented, the internal packages are tightly coupled to Netty internals and some integration modules may lag behind external library versions.
InvoicePrinter is a Ruby library for generating PDF invoices, with additional CLI and HTTP server interfaces. It takes structured invoice data (as Ruby objects or JSON) and generates formatted PDF documents using the Prawn library. The system consists of three main components: the core library for PDF generation, a command-line executable for direct use, and a server executable providing a HTTP API. The architecture shows good separation of concerns with distinct modules for data models, PDF rendering, font handling, and server interface.
copyparty is a portable, multi-protocol file server written in Python. It serves files over HTTP/WebDAV, FTP, SFTP, TFTP, and SMB/CIFS, with a rich web UI for browsing, uploading (resumable, chunked, deduplicated), searching, and media playback. The server supports user authentication, per-volume permissions, event hooks, metadata extraction, thumbnail generation, and audio transcoding. It can run on minimal dependencies (Python 3.3+), and is packaged as a self-extracting script, Docker image, or native installer. The architecture is modular: a central service hub (SvcHub) orchestrates protocol servers, a virtual filesystem (VFS) enforces permissions, and a broker pattern handles parallel tasks. The codebase includes a large set of example hooks, handlers, and plugins for customization. While the project is actively maintained and well-documented, it carries some technical debt from supporting very old Python versions and vendored libraries.
go-webdav is a Go library implementing WebDAV (RFC 4918), CalDAV (RFC 4791), and CardDAV (RFC 6352) protocols. It provides client and server implementations for these protocols, with a clear separation between the HTTP handling layer and storage backends via a FileSystem interface. The library includes a command-line tool to run a WebDAV server serving a local directory. The architecture is modular, with core WebDAV functionality in the 'webdav' package, CalDAV and CardDaV extensions in their respective packages, and low-level HTTP/XML handling in the 'internal' package. The library depends on go-ical and go-vcard for calendar and contact data processing.
Mochiweb is a lightweight, battle-tested HTTP server library written in Erlang. It provides a full HTTP/1.1 server with support for chunked transfer encoding, compression (gzip, zstd), WebSocket upgrades, and multipart form parsing. The library is designed as a collection of composable, parameterized modules, with a core socket server (`mochiweb_socket_server`) that manages an acceptor pool and delegates request handling to user-provided callback modules. This architecture has made Mochiweb the foundation for numerous Erlang web frameworks, including Nitrogen, Chicago Boss, and Webmachine. Key entry points include `mochiweb_http:start/1` for starting a plain HTTP listener and `mochiweb_socket_server:start/3` for custom socket servers. Request handling flows through `mochiweb_request` (parsing, body streaming, file serving) and `mochiweb_response` (header encoding, streaming, compression). The library also ships with standalone utilities: `mochijson2` for JSON encoding/decoding, `mochiweb_html` for loose HTML tokenization, `mochiweb_util` for URL/header parsing, and `mochiweb_headers` for case-insensitive header dictionaries. While the core is production-grade and actively maintained, some internal modules use deprecated OTP APIs (e.g., `httpd_util:rfc1123_date/0`, `{ssl_imp, new}`) and the state format in `mochiweb_socket_server` includes backward-compatibility shims. The example projects and test suite are comprehensive, covering edge cases from RFC 7230 and WebSocket protocols. Overall, Mochiweb remains a solid choice for embedding an HTTP server in Erlang applications, with several components (especially `mochijson2` and `mochiweb_util`) that are widely reused in isolation.
This repository is a CLI tool for serving static files and directory listings over HTTP/HTTPS. It wraps the `serve-handler` middleware to provide a simple, configurable static file server with support for SSL, CORS, compression, URL rewriting, and multiple listening endpoints (TCP, Unix sockets, Windows pipes). The architecture is a single Node.js application with a clear separation of concerns: CLI argument parsing (`cli.ts`), configuration loading with JSON schema validation (`config.ts`), server creation with HTTP/HTTPS support (`server.ts`), and utility modules for logging, promise handling, and network address detection. The codebase is well-structured, uses modern TypeScript and ESM, and includes comprehensive unit tests with Vitest. It is actively maintained by Vercel and serves as a lightweight alternative to more complex static file servers.
Jupiter is a governance-oriented microservice framework for Go, developed and used at Douyu. It provides a comprehensive set of components for building production-grade microservices, including multiple HTTP server wrappers (Gin, Echo, fasthttp, GoFrame), gRPC server and client, service discovery via etcd, distributed task scheduling (XXL-JOB), caching (freecache, LRU), configuration management (file, etcd, Apollo, HTTP), structured logging with rotation, Prometheus metrics, OpenTelemetry tracing, and resilience patterns (Sentinel circuit breaker/flow control). The framework also includes a CLI tool for project scaffolding and protobuf code generation plugins for Gin, Echo, error codes, and field masks. The architecture follows a modular, pluggable design with consistent patterns for configuration (StdConfig/RawConfig/Build), lifecycle hooks, interceptor chains, and singleton management. It emphasizes observability and governance out of the box, with built-in health checks, pprof endpoints, and metric export. The codebase is well-structured with extensive unit and e2e tests, though it carries some technical debt from supporting multiple HTTP frameworks and legacy dependencies. While primarily an application framework, it includes reusable utility packages (retry, field mask, load balancing, goroutine management) that can be extracted independently. The framework is actively maintained with regular commits and CI/CD pipelines, but some dependencies are outdated and there is code duplication in log rotation and cache implementations.
CherryPy is a mature, production-grade Python web framework that maps HTTP requests to Python callables using an object-oriented approach. It provides a built-in HTTP server (via Cheroot), a flexible configuration system, a publish/subscribe bus for lifecycle management, and a rich middleware/tool system for authentication, sessions, caching, static file serving, and more. The architecture is modular: the core request/response pipeline, dispatchers (tree-walking, method-based, routes), and a plugin system allow deep customization. CherryPy can be used standalone or embedded in other WSGI servers. It is not a data research project; it is a pure application framework with extensive testing and documentation.
Neutralinojs is a cross-platform desktop application framework that enables building native desktop apps using web technologies (HTML, CSS, JavaScript) without bundling a full browser engine. The core is a C++ binary that embeds a WebSocket server, a static file server, and a native API layer. Applications communicate with the backend via JSON-RPC over WebSocket, allowing access to OS-level features like file system, process management, clipboard, system info, and window control. The framework supports multiple deployment modes: window (native webview), browser, cloud, and chrome. The architecture is modular, with API controllers in `api/` (e.g., `app`, `fs`, `os`, `net`, `storage`, `clipboard`, `computer`) that each expose a set of methods. The server (`server/neuserver`) routes incoming WebSocket messages to the appropriate controller based on a method prefix. Authentication is handled via a token-based system (`auth/authbasic`), and permissions are enforced through allow/block lists (`auth/permission`). Extensions can be loaded as separate processes (`extensions_loader`), communicating via WebSocket with a shared token. The framework relies heavily on vendored third-party libraries: Asio for async I/O, WebSocket++ for WebSocket protocol, mbedTLS for TLS/crypto, and platform-specific libraries for hardware info, file watching, and clipboard. The build system uses CMake with platform-specific toolchains. The project includes a test suite using Mocha and a custom runner that launches the binary and executes JavaScript specs.
MixPHP is a high-performance PHP framework designed for CLI-mode development, supporting multiple server drivers including Swoole, Swow, WorkerMan, PHP-FPM, and the built-in CLI server. The framework is built as a modular monorepo with over 30 independent packages covering HTTP routing (Vega), WebSocket, gRPC, database access, Redis, CLI commands, validation, event dispatching, caching, dependency injection, and microservice infrastructure (service registry, circuit breaker, distributed tracing). The architecture emphasizes coroutine-based concurrency via Swoole, allowing seamless switching between server runtimes with minimal code changes. All components follow PSR standards (PSR-7, PSR-14, PSR-17, PSR-3) and are designed to be used independently, enabling developers to pick only what they need. The framework provides full-stack capabilities for building REST APIs, web applications, WebSocket services, gRPC servers, CLI tools, and microservices. It includes connection pooling for database and Redis, a PSR-14 event dispatcher, a standalone validation library, a generic object pool pattern, and a bean container for dependency injection. Examples and skeleton projects (api, web, cli, grpc, websocket) are provided to accelerate development. The codebase is well-tested with PHPUnit and includes continuous integration via GitHub Actions for splitting the monorepo into individual packages. While the framework is actively maintained and demonstrates strong craftsmanship, some modules show signs of technical drift such as deprecated classes (e.g., FileSystemApplicationContext, legacy cache handlers), reliance on specific Swoole versions, and copied Composer utilities that may diverge over time. The documentation is primarily in Chinese, and the Go counterpart (mix-go/mix) may split community attention.
Starman is a high-performance preforking PSGI/Plack web server written in Perl. It implements a robust HTTP/1.1 server with support for keep-alive connections, chunked transfer encoding, UNIX domain sockets, and SSL (experimental). The server uses a preforking model where a master process manages worker processes that handle HTTP requests. Key features include graceful restart handling via signals (HUP, TTIN/TTOU, QUIT), integration with Server::Starter for hot deploy, and PSGI extensions like psgix.informational for early hints. The codebase demonstrates careful attention to edge cases such as EINTR handling in system calls, proper chunked encoding parsing/generation, and HTTP/1.1 compliance.
Firefly is a high-performance asynchronous networking framework for the JVM, written in Java and Kotlin. It provides a comprehensive set of I/O primitives including HTTP/1.1, HTTP/2, WebSocket (RFC 6455), TCP, and UDP, with both client and server implementations. The framework is designed around Kotlin coroutines and Java NIO2 (AIO), offering non-blocking, backpressure-aware streams and a router-based HTTP server with support for content negotiation, CORS, static file serving, and HTTP/2 upgrade. It also includes built-in SLF4J logging with XML configuration, a JSON serialization service, a WeChat enterprise bot module, and a JNI helper for native code integration. The codebase is modular (firefly-common, firefly-net, firefly-slf4j, firefly-serialization, firefly-wechat, firefly-example) and demonstrates deep protocol-level craftsmanship with custom HPACK, Huffman coding, and state-machine parsers. While primarily a library for building network services, it also serves as a reference implementation for protocol handling on the JVM.
The idgen application is a Go-based tool for generating Chinese identity information (name, ID number, mobile number, bank card number, email, and address) for testing purposes. It provides both a command-line interface (CLI) with subcommands for each data type and an HTTP server mode that serves a web interface and API endpoints. The core data generation is handled by the github.com/mritd/chinaid/v2 dependency, while the application itself focuses on command parsing, output formatting, and server logic. The CLI uses Cobra for command structure and supports output in table, JSON, or CSV formats with optional clipboard copying. The server mode uses Go's embed package to bundle static files and provides REST endpoints for generating data in JSON or CSV format.
This is a Flutter-based cross-platform peer-to-peer file sharing application designed for local network transfers without server reliance. The app enables sharing of files, text, clipboard content, and folders between Android, iOS, Windows, macOS, Linux, and Web devices. Architecture follows a modular pattern with GetX for state management, featuring separate controllers (chat, device, settings, download), services (HTTP-based messaging via shelf, file serving, UDP discovery, clipboard), and platform-specific adapters. Key workflows include device discovery via multicast, HTTP-based message/file transfer, and adaptive UI rendering. The application demonstrates solid engineering practices with platform abstraction, reusable UI components, and thoughtful handling of cross-platform file operations, though exhibits some coupling between controllers and platform-specific code paths.
This repository is a collection of standalone example applications demonstrating features of the Gin web framework for Go. It includes over 30 examples covering routing, middleware, authentication, file uploads, WebSocket, server-sent events, gRPC integration, OpenTelemetry, and more. Each example is a self-contained Go program with its own main.go and dependencies. The codebase serves as a learning resource and reference for Gin patterns, but is not a cohesive production system. Many examples are simple and straightforward, though some demonstrate non-trivial patterns like rate limiting, struct-level validation, and concurrent room management.
Entralinked is a Java-based application that emulates Nintendo's Pokémon Global Link services for Pokémon Black/White and sequels. It functions as a standalone local server suite, providing DNS, GameSpy, and HTTP services to enable Nintendo DS/3DS consoles to access online features without save file modification. The architecture combines network servers (DNS on port 53, GameSpy on 29900, HTTP on 80/443), a Swing-based GUI for configuration, and a web dashboard for managing in-game Pokémon Dream World data. Key features include user/account management, DLC distribution, and save data synchronization via the PGL protocol. The project demonstrates solid engineering with reusable utility modules, clear separation of concerns, and active maintenance, though it relies on legacy protocols and contains some technical debt.