ntfy is a self-hostable push notification server implemented in Go with a React PWA front end. It exposes an HTTP API where clients publish messages with PUT/POST to a topic; subscribers receive them over WebSocket, SSE, or long polling. The server goes beyond basic pub-sub: it caches messages in SQLite, PostgreSQL, or memory, supports file/S3 attachments, and fans out to Firebase Cloud Messaging, Web Push, email via SMTP, Twilio calls, and Matrix. A full account system with tiers, ACLs, tokens, reservations, and Stripe billing sits alongside abuse controls like visitor rate limiting and IP bans. The repository also contains a Go client library and CLI for publishing and subscribing. Architecturally, this is a single Go binary with a build-tag feature matrix (e.g. noserver, nofirebase, nowebpush, nopayments) plus a React/Vite SPA served by the same process. Storage is backend-agnostic through interfaces: message.Cache, attachment.Store, user.Manager, and webpush.Store each have SQLite and PostgreSQL implementations, with schema migrations managed by a shared db/schema framework. The code stands out for extensive table-driven tests across both database backends, race-condition coverage, and careful security work such as template execution limits, Web Push endpoint allowlists, and a custom SigV4 S3 signing implementation. Main weaknesses are large central files, duplicated SQL for SQLite/PostgreSQL, and vendored forks of text/template and sprig that require manual synchronization with upstream.
This is the core Dapr repository, a CNCF-graduated distributed application runtime. In production it operates as a sidecar (daprd) alongside application containers, exposing HTTP and gRPC building-block APIs for state management, pub/sub messaging, service invocation, actors, durable workflows, secrets, configuration, distributed locks, jobs, and cryptography. The repo also contains the control-plane services: operator for Kubernetes resource management, injector for sidecar injection, placement for actor distribution, scheduler for distributed job/reminder coordination, and sentry for mTLS certificate issuance. The codebase is written primarily in Go with protobuf service definitions, Helm charts, and a large integration test harness that runs real system binaries. Architecturally, the runtime is modular: a component registry pattern supports pluggable state stores, pub/sub brokers, bindings, secret stores, and middleware; a runtime processor handles component lifecycle with hot-reload; the actor subsystem includes placement protocols, consistent hashing, reminders, timers, and workflow targets; and the workflow engine is built on durabletask-go with state signing, reruns, child workflows, and pending-start redrive. The integration test suite is extensive and treats process orchestration as a first-class concern, with dozens of suites for workflows, actors, scheduler, placement, subscriptions, state, and security. The engineering quality is strong: interface-driven abstractions, extensive fakes, versioned component APIs, resilient retry/backoff utilities, circuit breakers, and observability are all present. Occasional drift appears in deprecated OpenCensus metric usage, legacy version-skew patches, and a large build-tag matrix, but the project is actively maintained with recent commits, automated CI, and regular releases. This is a production infrastructure platform, not a data/research codebase.
Watermill is a Go library for building message-driven and event-driven applications. It is not a standalone service; applications embed it and use the core Publisher/Subscriber interfaces to communicate with brokers such as Kafka, RabbitMQ, NATS, Redis Streams, Google Cloud Pub/Sub, AWS SNS/SQS, SQL databases, or an in-memory Go channel. This repository contains the core library, reusable components, runnable examples, and small CLI tools, while broker-specific adapters and some integrations live in separate modules. The architecture is layered. At the bottom are the low-level Pub/Sub abstractions and the Message object with UUID metadata, payload, and Ack/Nack lifecycle semantics. The middle layer is the Router, which wires handlers into consumption loops and supports middleware and publisher/subscriber decorators. On top of that, optional components implement CQRS event/command buses and processors, topic forwarding, request-reply, delayed publishing, metrics, fan-in/fan-out, and requeuing. Middleware covers retry with exponential backoff, poison queues, deduplication, throttling, circuit breaking, correlation IDs, timeout enforcement, and panic recovery. The repository is extensively tested, including a universal pub/sub conformance suite intended for adapter authors to reuse, and GoChannel serves as a complete in-memory reference implementation. The examples demonstrate real production patterns: CQRS with protobuf, ordered events, exactly-once delivery counters, outbox/transactional event forwarding, server-sent event feeds, webhook ingestion, and consumer groups. There is no data research component; this is purely a software library/application framework.
uWebSockets.js is a high-performance native Node.js addon that wraps the uWebSockets C++ library to provide blazing-fast HTTP/1.1, WebSocket, and QUIC (HTTP/3) server capabilities. It exposes a clean TypeScript/JavaScript API with features such as per-message compression, backpressure management, streaming responses, pub/sub, and SNI support. The architecture centers on a V8 addon compiled for multiple Node.js ABIs (22/24/26) using a custom build script that also builds BoringSSL and lsquic. The JavaScript layer defines a DeclarativeResponse class that encodes response instructions as typed array opcodes for zero-copy native execution. The codebase includes extensive benchmarks with A/B comparison, automated fuzz testing, and a standalone V8 host for testing. While primarily an application library, it incorporates sophisticated data engineering patterns in its benchmarking and performance measurement infrastructure. The repository is actively maintained with recent commits and low open issue count, though it depends on a volatile V8 API and an external submodule.
This repository is a Redis-compatible in-memory data structure server with significant custom extensions, including vector similarity search via HNSW (vector-sets module), rate limiting (GCRA), key eviction protection (BLESS), and a comprehensive module system. The architecture is a single-threaded event loop (ae) with optional IO threads, supporting a wide range of data structures: strings, hashes, lists, sets, sorted sets, streams, geospatial indexes, HyperLogLog, and bitfields. Persistence is provided via RDB snapshots and AOF logs, with replication and cluster support. The codebase is a fork/derivative of Redis/Valkey, incorporating additional features not present in upstream, such as hash field expiration (ebuckets/estore), per-key metadata (keymeta), and a Fenwick tree-based key selection (kvstore). Key entry points include the redis-server daemon, redis-cli, redis-benchmark, and module loading via the redismodule.h API. External dependencies include jemalloc, hiredis, Lua 5.1, linenoise, tre, xxhash, OpenSSL, and optional ZSTD compression. The system is designed for high throughput and low latency, with extensive use of custom memory management (zmalloc) and data structure optimizations.
RMQTT is a high-performance, distributed MQTT broker written in Rust, supporting MQTT v3.1, v3.1.1, and v5.0 protocols. It provides TCP/TLS/WebSocket/QUIC transports, a plugin-based extensibility system, multiple clustering modes (broadcast and Raft), persistent session and message storage (sled, Redis), authentication via HTTP or JWT, ACL rules, and bridges to Kafka, Pulsar, NATS, and ReductStore. The broker includes a built-in HTTP management API with a Vue.js dashboard and a comprehensive test suite covering conformance, stress, and chaos scenarios. Production features include circuit breakers, rate limiting, metrics export, and configuration-driven operation. The codebase is well-structured with clean abstractions, reusable components (codec, network builder, hook system), and active maintenance, though the dual clustering implementations and extensive feature flags introduce some complexity.
Iodine is a high-performance concurrent web server for Ruby applications, built as a wrapper around the C-based facil.io framework. It provides native HTTP/WebSocket/Server-Sent Events support, Rack compliance for serving Ruby web applications, and a built-in Pub/Sub system with optional Redis scaling for horizontal distribution. The architecture follows a master-worker model using multiple processes and threads to handle thousands of concurrent connections, with critical networking components implemented in C for performance and Ruby bindings for developer productivity. Key features include static file serving with gzip and X-Sendfile support, a secure Mustache template engine with automatic HTML escaping, a fast JSON parser claiming 20-90% speed improvements over Ruby's standard library, and TLS support (though marked as having known issues for production use). The server integrates with Rack applications through a custom handler and provides upgrade hooks for WebSocket/SSE protocols via the Rack environment. Pub/Sub functionality uses an engine pattern allowing swap between internal cluster-based and external Redis backends. Entry points include the `exe/iodine` CLI executable and programmatic controls via `Iodine.listen`, `Iodine.start`, and `Iodine.stop`. Data flows involve HTTP requests parsed by the C-based HTTP processor, routed to Rack applications or static file handlers, with WebSocket connections upgraded via Rack's `env['rack.upgrade?']` mechanism. The Pub/Sub system operates independently for real-time messaging across processes or machines. External dependencies include the vendored facil.io C library, OpenSSL development headers for TLS support, and optionally the Redis gem for clustered Pub/Sub.
This repository contains Google Cloud Platform (GCP) service code samples in Go, designed to demonstrate API usage patterns and implementation techniques for various GCP services. The samples are organized by service (e.g., BigQuery, Firestore, Cloud Functions, Compute Engine) and include both runnable examples (main.go files) and library snippets. The repository serves as a practical reference for developers building applications on GCP, showing how to initialize clients, handle errors, manage resources, and integrate services. While not a single cohesive application, it provides executable samples that can be adapted for production use, with many samples following client initialization, context handling, and error handling patterns. The repository includes testing infrastructure and CI/CD configurations to validate samples against real GCP projects.
This repository is the official JavaScript/TypeScript client SDK for Centrifugo, a scalable real-time messaging server. It provides a robust, event-driven client (Centrifuge class) that manages persistent connections via multiple transports (WebSocket, SSE, HTTP stream, SockJS, WebTransport), handles token-based authentication and subscription authorization, and supports three subscription models: stream (standard channel), map (keyed data), and shared poll (polling with version tracking). The SDK also implements advanced features like automatic reconnection with exponential backoff, recovery from connection drops using offset/epoch, command batching for HTTP transports, and delta compression for efficient updates. The architecture is library-oriented with a clear separation of concerns: transport implementations are abstracted behind a common interface, the main client class manages connection state and dispatch ordering via a serial promise chain, and each subscription type extends a base class with its own state machine (stream, map three-phase, shared poll). The codebase is extensively tested with both unit tests (using a fake server) and integration tests against a real Centrifugo instance in Docker. The SDK is published on npm, supports CJS and ESM builds, and includes protobuf codec support. Notable patterns include a transport abstraction with dependency injection that allows easy addition of new transports, a serial dispatch chain ensuring ordered response processing, and a per-key publish debounce mechanism. The library is actively maintained with ongoing work on refactoring subscription types as documented in NEXT_MAJOR_SUBSCRIPTION_TYPES.md. The repository also demonstrates high craftsmanship in its comprehensive test coverage, graceful error handling, and careful handling of edge cases like stale tokens, network interruptions, and concurrent operations.
This repository is a mature, production-grade WAMP v2 client library for Node.js and browsers. The actual code implements the Web Application Messaging Protocol with full pub/sub and RPC support over WebSocket, including auto-reconnect, multiple serializers (JSON, CBOR, MsgPack), and authentication methods (ticket, WAMP-CRA, cryptosign). The architecture is modular: a core Wampy class in `src/wampy.ts` accepts pluggable serializers via a common interface, and authentication plugins are registered in a hashmap. The library also includes a CLI tool (`cmd/cli.ts`) for rapid WAMP API debugging. External dependencies are minimal (WebSocket, Node.js crypto for cryptosign). The codebase is written in TypeScript with strict mode, dual ESM/CJS builds, and a comprehensive test suite covering connectivity, PubSub, RPC, and advanced features like progressive calls and Payload PassThru Mode. Despite large test files and some legacy patterns, the code is well-structured and follows promises/async-await throughout.
redis-plus-plus is a production-grade C++ Redis client library built on hiredis, providing synchronous, asynchronous (libuv), and experimental coroutine (C++20) APIs. It covers the full Redis command surface including strings, hashes, lists, sets, sorted sets, streams, geospatial, hyperloglog, pub/sub, scripting, transactions, pipelines, and server commands. The architecture separates low-level connection management (connection pools, shard pools for clusters, sentinel discovery) from high-level facade classes (Redis, RedisCluster, AsyncRedis, AsyncRedisCluster, QueuedRedis for pipelined/transactional usage). Key entry points include the main sync header `redis++.h`, async header `async_redis++.h`, and coroutine header `co_redis++.h`. Data flows involve constructing Redis commands via `CmdArgs` and `cmd_formatter.h`, sending them through `Connection` objects (optionally pooled), and parsing replies with `reply.h`. The library depends on hiredis for raw Redis protocol, libuv for async I/O, and optionally Boost or OpenSSL for advanced features. It includes a comprehensive test suite covering all commands, multi-threading, cluster, sentinel, and distributed locking patterns (Redlock).
This repository is the official W3C WebSub specification (formerly PubSubHubbub), a decentralized publish/subscribe protocol over HTTP. It is not a software application or data pipeline; it contains the normative ReSpec specification documents, implementation reports, and W3C governance metadata. The core deliverable is source.html, with staged snapshots for FPWD, Working Draft, and the 2018 Recommendation. The spec defines three roles — publisher, subscriber, and hub — and specifies discovery via link rel=hub/self, hub subscription/unsubscription with lease management, content distribution via POST, and optional authenticated distribution using HMAC signatures. It also includes conformance classes and implementation report templates that multiple independent projects (Google, Mastodon, Twitch, Superfeedr, etc.) have used to self-certify interoperability.
The CachingFramework.Redis library is a .NET caching abstraction built on top of StackExchange.Redis. It provides a rich set of features including cache-aside patterns, tag-based invalidation, support for Redis data structures (strings, hashes, sets, sorted sets, bitmaps, HyperLogLog, geospatial), pub/sub, and key space notifications. The architecture centers around RedisContext as the main entry point, which provides access to modular features like Cache, Collections, GeoSpatial, PubSub, and KeyEvents. The library employs a provider pattern for encapsulating Redis operations and offers extensible serialization via an ISerializer interface with multiple implementations (binary, JSON, MessagePack, MemoryPack). It is designed for dependency injection and follows .NET best practices with async/await support and proper configuration management.
This repository is the Go Cloud Development Kit (Go CDK), a multi-cloud SDK that provides portable, driver-based abstractions for common cloud services including blob storage, pub/sub messaging, document stores, runtime configuration variables, secrets management, and SQL databases (MySQL/PostgreSQL). The architecture follows a consistent pattern: each service defines a driver interface (e.g., `driver.Bucket`, `driver.Topic`, `driver.Collection`) and a portable wrapper that adds error handling, retries, OpenTelemetry instrumentation, and a URL-based opener multiplexer (`URLMux`). Concrete drivers exist for Google Cloud Platform (GCS, Pub/Sub, Firestore, Cloud SQL, KMS), Amazon Web Services (S3, SNS/SQS, DynamoDB, Parameter Store, Secrets Manager, KMS), Microsoft Azure (Blob Storage, Service Bus, Key Vault), and local/testing backends (in-memory, filesystem). The project also includes sample applications (guestbook, order processing, CLI tools), a Hugo-based documentation website, and extensive conformance test suites that use recorded HTTP/gRPC interactions for deterministic replay testing. The codebase demonstrates strong architectural patterns (driver abstraction, URL-based resource opening, batcher for pub/sub, codec for document stores) and comprehensive observability via OpenTelemetry. However, the code uses a non-standard Go dialect (e.g., `import` with quoted strings, `type` for interfaces, `var` for variables) that is not standard Go, which significantly limits tooling support, contributor familiarity, and reusability outside this project. Many drivers and internal utilities are tightly coupled to this custom language, making extraction difficult. The project appears to be in alpha status with several incomplete features, TODOs, and a large dependency surface across multiple cloud SDKs, indicating a high maintenance burden. The last commit date is in the future (2026-10-01), which is likely erroneous, but the overall activity suggests the project may have slowed or been abandoned.