Projects sharing features with MQTT.js

NATS Server is a high-performance, lightweight messaging system designed for cloud-native applications, edge computing, and distributed microservices. It functions as a distributed publish-subscribe broker that routes messages using hierarchical, dot-separated subject strings, enabling decoupled communication between services without requiring centralized broker lookups. The system supports core messaging patterns including asynchronous publish-subscribe, request-reply, and load-balanced queue processing. The platform distinguishes itself through a decentralized architecture that eliminates t

Highly scalable realtime pub/sub and RPC framework

MQTTX is a cross-platform MQTT client application designed for testing, debugging, and managing MQTT brokers. It supports both MQTT v3.1.1 and v5.0, enables simultaneous management of multiple broker connections, and provides an interactive chat-style interface for publishing and subscribing with configurable quality of service, payload transformation, and topic visualization. The client can be used as a desktop application, a command-line tool, or a self-hosted web client deployable via Docker. What sets MQTTX apart is its integration of AI-assisted workflows, allowing users to generate MQTT

KubeEdge is a distributed edge computing framework that extends Kubernetes to manage containerized workloads and hardware devices at the edge. It functions as a Kubernetes edge orchestration system, allowing the deployment and management of applications across distributed edge nodes using native Kubernetes APIs and workflows. The project distinguishes itself through a specialized focus on IoT integration and node autonomy. It employs digital-twin state modeling to represent physical hardware devices as virtual objects, utilizing an MQTT-based messaging bus for communication with heterogeneous

uWebSockets is a high-performance networking engine providing an HTTP web server and a WebSocket server framework. It implements a multi-threaded event loop architecture to deploy isolated application instances across multiple CPU cores and includes an SSL/TLS network layer for secure, encrypted communication. The project features a dedicated WebSocket pub/sub engine for distributing messages to specific groups of connected clients. It optimizes network throughput through syscall corking to reduce kernel overhead and employs payload compression to minimize data transfer sizes. The system cov

uWebSockets is a C++ networking framework that serves as a high-performance WebSocket server library, HTTP web server, and pub-sub messaging system. It provides the infrastructure necessary to handle standard web requests and maintain low-latency, bidirectional connections between clients and servers. The framework is distinguished by its use of template meta-programming for compile-time optimization and zero-copy buffer management to minimize memory latency. It utilizes a backend-agnostic event loop and static route resolution to process network traffic with minimal runtime overhead. The pr

Hazelcast is a distributed data platform that combines an in-memory data grid with a stream processing engine to support real-time analytics and event-driven applications. It functions as a partitioned, distributed key-value store that replicates data across cluster nodes to provide low-latency access and high availability. The platform also serves as a distributed SQL query engine, allowing users to execute standard SQL statements against both in-memory datasets and external data sources. What distinguishes Hazelcast is its use of a distributed consensus subsystem to maintain strongly consis

Apache Pulsar is a cloud-native message queue and distributed publish-subscribe messaging system. It serves as a multi-tenant event streaming platform designed to route data streams for asynchronous communication between producers and consumers. The system distinguishes itself through geo-replication, synchronizing data across multiple geographic regions to ensure high availability and low latency. It implements a multi-tenant architecture that provides isolation and resource management for millions of independent topics. The platform covers high-throughput data streaming and event-driven da

Sarama is a Go client library for producing and consuming messages from Apache Kafka clusters. It provides dedicated interfaces for a message producer to send typed data packets and a message consumer to read and process continuous data streams from Kafka topics. The library includes a mocking framework and simulation layer that mimics Kafka broker behavior. These tools allow for the testing of client applications and messaging logic without requiring a live cluster. The project handles cluster connectivity and integration through the implementation of the Kafka binary protocol over TCP. It

evcc is an open-source home energy management system and solar charging optimization engine. It coordinates solar inverters, electric vehicle chargers, home batteries, and smart devices to route surplus solar energy to load points, optimizing energy use and minimizing grid costs. The platform functions as a multi-protocol charger orchestrator and ISO 15118-2 plug and charge controller, enabling automatic vehicle identification and battery state retrieval. It distinguishes itself through a plugin-based device abstraction layer and protocol-agnostic drivers that unify control across diverse har

deepstream.io is an open-source realtime server that synchronizes JSON records, events, and remote procedure calls across clients and backend services. It functions as a realtime data sync server, event pub/sub server, record database server, and RPC server, all within a single platform. The server authenticates and authorizes every message using multiple strategies including JWT, HTTP, and file-based credentials, with a declarative permission language controlling access to records, events, and RPCs at a granular level. The platform distinguishes itself through its combination of realtime dat

This is a Golang client library for interacting with a cloud native distributed messaging system. It provides the necessary tools for Go applications to exchange messages using publish-subscribe and request-reply patterns, as well as specialized clients for managing persistent streams and distributed storage. The library includes a JetStream client for durable message streaming and replay, a Key-Value store client for managing distributed state with versioning and watchers, and an Object Store client for the storage and retrieval of large binary files via chunked delivery. The implementation

Olric is a distributed data grid and in-memory key-value store that partitions and replicates data across a cluster of servers. It serves as a shared memory system for managing distributed maps, performing atomic operations, and acting as an in-memory data cache. The system provides a distributed locking mechanism for concurrency control and a pub-sub messaging system that broadcasts and routes messages over named channels across the cluster. The platform covers wide-ranging capabilities including cluster management and orchestration, data replication with configurable quorums, and automated

Rueidis is a high-performance Redis client library for Go that provides a type-safe and asynchronous interface for interacting with Redis servers. It includes a full implementation of the Redis serialization protocol and a dedicated connection manager to handle pooling, multiplexing, and automatic pipelining. The library is distinguished by its support for RDMA connectivity to reduce latency and CPU overhead. It features a distributed lock manager that implements majority-based locking and optimistic concurrency control, as well as client-side caching with invalidation signals to minimize net

This project is a Python implementation of the Socket.IO bidirectional event protocol. It serves as a realtime communication framework designed for low-latency, event-driven data exchange between a server and multiple connected clients. The framework functions as a distributed message queue integrator, allowing communication to be synchronized across multiple server instances. It manages user sessions and client connections across distributed environments using a shared message queue for synchronization. The system provides capabilities for bidirectional event exchange, real-time state synch

goim

go-cloud is a toolkit of cloud-agnostic libraries that provide portable Go interfaces for interacting with common cloud services. It enables multi-cloud application development by decoupling business logic from specific provider API implementations. The project utilizes a driver-based system to map generic interface calls to vendor-specific requests. This allows applications to switch between different cloud backends for blob storage, relational databases, and asynchronous publish-subscribe messaging without changing the core application code. Beyond storage and messaging, the toolkit includ

Godis is a Redis-compatible in-memory database and distributed key-value store. It functions as a replicated data store and distributed message broker, implementing the Redis protocol to manage complex data structures in memory. The system provides a geospatial indexing engine for proximity-based queries and distance calculations. It ensures high availability and data durability through master-slave replication and write-ahead logging. The project covers a wide range of capabilities including the management of strings, hash maps, lists, and sorted sets. It supports distributed data clusterin

This is a Go client library and protocol implementation for interacting with message brokers using the AMQP 0.9.1 standard. It serves as an asynchronous messaging toolkit and message queue client for implementing producer and consumer patterns. The library provides a programmatic interface for managing the full message lifecycle, including publishing, consumption, and delivery acknowledgments. It supports reliable delivery mechanisms such as publishing confirmations and atomic transactions. The project covers the administration of routing topologies through the declaration and binding of que

PubSubJS is a lightweight JavaScript library that implements the publish-subscribe pattern to manage decoupled communication between different parts of an application. It functions as a dependency-free message broker and event bus, allowing components to exchange data without requiring direct dependencies. The system enables the orchestration of events through named topics, allowing developers to register subscriber callbacks and broadcast messages to all interested listeners. It specifically supports the decoupling of component communication and the notification of state changes across multi

Valetudo is a custom firmware project for robot vacuums that enables local-only control, removing dependencies on cloud servers and protecting user privacy. It replaces proprietary vendor binaries with open source software to ensure that data, including floor plans and images, is not uploaded to external clouds. The project distinguishes itself by providing a rooted firmware installation process that prevents forced vendor updates. It implements a standardized control interface across different hardware brands and utilizes an MQTT-based message bus to facilitate integration with open source a

This library is an MQTT client implementation designed for resource-constrained embedded systems, specifically targeting ESP8266 microcontrollers. It provides a framework for establishing persistent network connections to exchange data with remote messaging brokers, enabling reliable communication for IoT devices. The library distinguishes itself through its ability to maintain simultaneous connections to multiple independent messaging brokers, facilitating complex data routing across distributed environments. It utilizes a state-machine approach to manage connection lifecycles, including aut

Mosquitto is a message broker that implements the MQTT protocol to route messages between connected devices and applications. It functions as a central hub for event-driven communication, supporting message exchange over both raw TCP and WebSockets. The software provides a persistent messaging infrastructure by writing message queues and client subscription states to disk, ensuring data recovery following service interruptions. The broker distinguishes itself through its support for distributed system synchronization, allowing for the federation of multiple remote brokers to share data across

This project is a Java messaging software development kit designed to facilitate real-time data exchange between applications and message brokers. It functions as an MQTT client library, providing the necessary tools to implement publish-and-subscribe messaging patterns within distributed systems and internet-connected device environments. The library distinguishes itself through its focus on resilient network connectivity and reliable message delivery. It manages persistent connections through internal state machines that handle automatic reconnection and keep-alive heartbeats, ensuring stab

Garnet is a multi-threaded in-memory database and distributed key-value store. It functions as a high-performance remote cache store that implements the RESP wire protocol to maintain compatibility with existing Redis clients and libraries. The project is distinguished by a shared-memory architecture that enables parallel request processing across multiple cores for sub-millisecond latency. It features a tiered storage system that automatically offloads colder data from system memory to SSD or cloud storage layers, and includes a specialized vector search database for high-dimensional similar

Nameko is a Python microservices framework designed for building distributed systems using a service-oriented architecture. It provides a system for implementing remote procedure calls and asynchronous event broadcasting between decoupled services by utilizing the AMQP protocol and message brokers. The framework includes a managed HTTP client pool to fetch remote content while preventing resource exhaustion. It also functions as a microservice web gateway, allowing internal service logic to be exposed as external web endpoints via standard HTTP protocols. The project covers broad capabilitie

General purpose redis client