Apache Kafka is a distributed event streaming platform used for high-performance data pipelines, streaming analytics, data integration, and mission-critical applications. The repository contains the core broker (with KRaft consensus), client libraries (producer, consumer, admin), Kafka Streams (stream processing DSL and Processor API), Kafka Connect (data integration framework), and supporting modules (metadata management, storage, security, testing tools like Trogdor). The architecture is modular: the broker is a JVM application, clients are libraries, and Streams/Connect are frameworks that run on top. Key entry points include KafkaServer, KafkaProducer, KafkaConsumer, KafkaStreams, and Connect workers. Data flows involve producers writing records to topics, consumers reading, streams transforming, and connect importing/exporting. External dependencies include Java, Gradle, and optionally ZooKeeper (legacy). The codebase demonstrates exceptional craftsmanship with clean abstractions, extensive use of Java records and sealed interfaces, a well-designed metrics system, and a robust event-driven consumer internals pattern.
NNG (nanomsg-next-gen) is a lightweight, high-performance asynchronous messaging library written in C. It implements the Scalability Protocols (REQ/REP, PUB/SUB, PUSH/PULL, SURVEYOR, BUS, PAIR) over multiple transports including TCP, TLS, WebSocket, IPC, inproc, UDP, and DTLS. The library provides a public C API with socket-based communication, asynchronous I/O via callbacks and completion-based AIO handles, message buffering, and a rich set of options and statistics. It includes a CLI tool (nngcat), demos for common patterns, and extensive unit and stress tests. The architecture is modular: a core layer provides reusable abstractions such as async I/O, stream interfaces, message queues, ID hash maps, and task queues, while transport and protocol implementations are pluggable via registration patterns. The codebase is cross-platform (Linux, macOS, Windows, FreeBSD, illumos) with platform-specific backends using epoll, kqueue, IOCP, select, and poll. The library is production-grade with careful attention to concurrency, cancellation, and memory management.
Socket.IO is a real-time bidirectional event-based communication library for Node.js and the browser. The repository is a monorepo containing multiple packages: the server (`socket.io`), client (`socket.io-client`), low-level transport layer (`engine.io`, `engine.io-client`), packet parsers (`engine.io-parser`, `socket.io-parser`), adapters for horizontal scaling (`socket.io-adapter`, `@socket.io/cluster-adapter`, `@socket.io/cluster-engine`), and emitters for cross-process communication (`@socket.io/postgres-emitter`, `@socket.io/redis-streams-emitter`). The architecture is layered: Engine.IO handles transport abstraction (HTTP long-polling, WebSocket, WebTransport) with upgrade mechanisms, while Socket.IO adds higher-level features like namespaces, rooms, acknowledgements, and connection state recovery. The client library provides automatic reconnection with exponential backoff, binary data support, and multiplexing across namespaces. The codebase is written in TypeScript with extensive test coverage, protocol documentation, and a rich set of examples demonstrating integration with various frameworks (React, Angular, Vue, Next.js, NestJS) and deployment patterns (clustering, load balancing, authentication).
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 a high-quality Go client library for Apache Kafka, providing both low-level (Conn, Transport) and high-level (Reader, Writer, ConsumerGroup) APIs for producing and consuming messages. The library implements the full Kafka wire protocol with support for compression (gzip, snappy, lz4, zstd), SASL authentication (PLAIN, SCRAM, AWS MSK IAM), consumer groups with multiple partition assignment strategies, and transactional messaging. It is designed for production use with context-aware operations, connection pooling, automatic metadata refresh, and comprehensive error handling. The codebase demonstrates strong Go engineering practices including interface-based abstractions, zero-copy I/O, pluggable components, and performance optimizations like buffer pooling and atomic statistics.
mini-redis is an incomplete, idiomatic implementation of a Redis client and server built with Tokio, serving as a teaching resource for asynchronous Rust patterns. The server supports key-value operations (GET, SET) with optional TTL, pub/sub (PUBLISH, SUBSCRIBE, UNSUBSCRIBE), and PING. It demonstrates graceful shutdown, connection limiting via a semaphore, and key expiration using a background task. The client library provides async (Client), blocking (BlockingClient), and buffered (BufferedClient) clients, with a Subscriber type for pub/sub. The codebase is well-structured, extensively commented, and showcases patterns such as frame-level protocol parsing, shared state with std::sync::Mutex, message-passing for multiplexing, and broadcast channels for shutdown signals. It is not intended for production use but is a high-quality reference for learning Tokio and async Rust.
This is the official NATS C client library (nats.c), a production-grade C library providing full support for the NATS messaging system. It implements core publish/subscribe, request-reply, queue groups, and advanced features including JetStream (streams, consumers, key-value store, object store), a microservices framework, and legacy NATS Streaming support. The library is designed for high performance and reliability, with built-in reconnection, TLS/SSL, authentication (NKeys, JWT), and event loop integration (libevent, libuv). It exposes a comprehensive C API with hundreds of functions, and includes extensive examples and documentation. The codebase is well-structured with platform abstractions for Unix and Windows, and internal modules for protocol parsing, connection management, threading, and memory management. While the library is actively maintained and widely used, it carries some technical debt from legacy Streaming support and a large, tightly-coupled internal architecture.
MessagePipe is a high-performance C# library for in-process and distributed messaging, implementing pub/sub, mediator/CQRS, and request/response patterns with a flexible filter pipeline. It supports both synchronous and asynchronous operations, keyed and keyless subscriptions, and buffered/observable adapters. The library is DI-container agnostic, with first-class integrations for Microsoft.Extensions.DependencyInjection, Unity (Zenject, VContainer), and a built-in lightweight container. Distributed transports include TCP, UDP, Named Pipes, Unix Domain Sockets, Redis, and NATS, with MessagePack binary serialization. A Roslyn analyzer (MPA001) detects forgotten subscription disposal. The codebase is well-structured and performance-optimized (lock-free data structures, pooling, custom awaiters), but suffers from significant code duplication between .NET and Unity variants and embeds large third-party libraries (Zenject, MessagePack) directly in the Unity project, increasing maintenance burden.
Proto.Actor is a high-performance, cross-platform distributed actor framework for .NET. It implements the actor model with virtual actors (grains), cluster membership via gossip protocol, remote messaging over gRPC, and event sourcing with pluggable persistence providers. The architecture is modular: the core actor runtime (Proto.Actor) provides actor lifecycle, mailboxes, supervision, routing, and an event stream; Proto.Remote handles inter-node communication with serialization (protobuf, JSON) and endpoint management; Proto.Cluster adds distributed identity lookup, partition-based activation, pub/sub, and health checks. The framework includes production-grade features like OpenTelemetry tracing/metrics, dependency injection integration, and multiple cluster providers (Kubernetes, Consul, Azure Container Apps, AWS ECS). Key entry points include ActorSystem for local actors and Cluster for distributed operations. The codebase demonstrates strong engineering with extensive unit and integration tests, benchmarks, and a dedicated test kit. Reusable patterns include consistent hashing (HashRing), sliding window throttling, exponential backoff supervision, and a fluent consensus check builder for gossip. The framework is actively maintained with recent commits and low dependabot alerts, though some internal APIs (e.g., obsolete loggers, CouchbaseNetClient 2.7.x) show moderate technical drift. Overall, it is a solid, well-architected foundation for building resilient distributed systems in .NET.
Glyphr Studio 2 is a fully functional, web-based font editor that runs entirely in the browser. It provides a complete workflow for designing typefaces: creating and editing glyphs via a canvas with Bézier path tools, managing kerning pairs and ligatures, building reusable component instances, and importing/exporting fonts in OTF, TTF, WOFF, WOFF2, and SVG font formats. The application is built as a single-page application using vanilla JavaScript (ES modules) with Vite as the build tool, and it relies on several external libraries: font-flux-js for binary font I/O, bezier-boolean for boolean path operations, and svg-to-bezier for SVG outline parsing. The architecture separates project data (a hierarchical model of glyphs, paths, points, components, and settings) from the UI layer, which is composed of custom web components (e.g., FancyButton, EditCanvas, DisplayCanvas) and a publish-subscribe event system for decoupled state updates. Key entry points include src/app/main.js (application bootstrap), src/project_editor/project_editor.js (central controller managing navigation, history, and selection), and src/formats_io/otf/font_export.js (binary font generation). The editor supports multi-project editing, undo/redo with IndexedDB persistence, and a variety of panels for attributes, layers, guides, and quality checks. The codebase demonstrates solid engineering practices with a clear data model, reusable UI components, and comprehensive unit tests for core data structures and import/export routines, though some areas (e.g., UI panels) have less test coverage.
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.