Projects sharing features with Pika

This project provides a queue driver that integrates RabbitMQ as a message broker within the Laravel framework. It acts as a bridge between the application and the broker, enabling asynchronous task offloading and distributed system integration by mapping framework-specific job dispatching commands to the native AMQP protocol. The driver is designed to be compatible with the native dashboard interface for monitoring and managing background jobs. It supports high-volume job processing through persistent connection streaming, which maintains long-lived network sockets to the broker to reduce la

Seneca is a message-driven architecture framework and microservices toolkit for Node.js. It functions as a distributed task orchestrator and pattern-based message router, allowing developers to build systems of decoupled services that communicate via a message bus. The framework distinguishes itself through a modular plugin system that organizes business logic into reusable, configurable modules. It supports dynamic action extensions, enabling new handlers to wrap or override existing action patterns to inject custom logic without modifying original code. The system covers a broad range of c

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

Evio is a high-performance networking library for Go that provides a non-blocking socket framework. It utilizes an event loop to process TCP, UDP, and Unix domain socket traffic through a low-level asynchronous protocol interface. The project functions as a multi-core network load balancer, distributing connections across multiple CPU cores using round-robin or least-connections strategies. It supports socket reuse, allowing multiple sockets on a single host to bind to the same port. The library covers a broad range of socket management and packet processing capabilities, including multi-pro

This project is a technical study and analysis guide focused on the internal architecture of Node.js. It provides an in-depth examination of the runtime, focusing on how the engine manages memory handles, executes asynchronous operations, and implements core module logic. The guide specifically analyzes the integration of native C++ classes and functions into JavaScript and documents the behavior of the libuv event loop. It includes detailed references for optimizing performance by identifying V8 compiler bailouts and profiling execution to improve resource efficiency. The material covers a

MQTT.js is a JavaScript client library and asynchronous messaging client used to connect to message brokers and exchange data via the MQTT protocol. It provides a broker interface for publishing and subscribing to topics, and includes a command-line interface for interacting with brokers without writing code. The library supports multiple network layers, including TCP, TLS, and WebSockets, and allows for custom WebSocket construction and transport injection to handle specific headers or subprotocols. It implements bandwidth reduction through topic aliasing, which replaces repetitive topic str

Swift NIO is a low-level, event-driven network framework for the Swift language. It serves as an asynchronous network protocol stack and I/O library designed to build high-performance network servers and clients that handle thousands of simultaneous connections. The framework functions as a high-concurrency network engine that dispatches events across multiple CPU cores. It enables the implementation of custom network protocols by processing raw bytes through a sequence of reusable data transformation handlers. The system provides capabilities for non-blocking I/O multiplexing, asynchronous

Netpoll is an event-driven network framework and non-blocking I/O library designed to manage concurrent TCP and Unix domain socket connections. It utilizes a non-blocking event loop to monitor file descriptors and trigger callbacks for read and write events, serving as a high-performance socket manager and TCP network poller. The framework optimizes throughput across CPU cores by distributing incoming network connections across multiple pollers. It implements zero-copy networking primitives, using linked buffers and specialized memory management to read and write data while minimizing memory

Socket.io is a real-time communication engine that enables bidirectional, event-based data exchange between clients and servers. It provides a robust transport-agnostic protocol layer that automatically manages connection lifecycles, including heartbeat signals, automatic reconnection, and seamless fallback between WebSockets and HTTP long-polling. By maintaining persistent links, it ensures reliable messaging across diverse network environments. The project distinguishes itself through a scalable, distributed architecture that supports multi-node synchronization and room-based message routin

This project is an asynchronous messaging framework designed for building interactive applications on the Telegram platform. It functions as a comprehensive wrapper that maps native platform methods and update types into structured objects, enabling developers to create event-driven services that respond to real-time user input. By integrating with standard event loops, the library facilitates high-throughput communication and non-blocking message processing. The framework distinguishes itself through a sophisticated update-driven dispatcher pattern that routes incoming messages to specific h

netty-socketio is a Java implementation of a Socket.IO server designed for real-time bidirectional communication between clients and servers. It functions as a real-time event engine and WebSocket communication server, utilizing the Netty network framework to manage high-performance socket connections. The project enables distributed socket server scaling by acting as a distributed message broker. It synchronizes client states and broadcasts messages across multiple server nodes through the use of an external data store. The system manages traffic via namespace-based connection routing and r

This project is an asyncio database abstraction layer that provides a common interface for performing non-blocking database operations in Python. It functions as an asynchronous database driver wrapper and a SQL expression builder, allowing for the construction of raw SQL strings from structured Python objects. The library includes an asyncio connection pool manager that utilizes task-local storage to handle connection lifecycles and reduce resource overhead. It also serves as an async database transaction manager, wrapping operations in atomic transactions and savepoints to maintain data int

Model Context Protocol is a standardized framework for connecting large language models to external data sources and executable tools. It enables the creation of a universal interface where servers expose tools, resources, and prompts that can be discovered and utilized by various AI clients. The protocol utilizes a JSON-RPC message system that is transport-agnostic, supporting both standard input/output for local processes and HTTP with server-sent events for remote connections. It emphasizes security and control by delegating model sampling to the client to keep API keys secure from servers

smoltcp is a TCP/IP stack and network protocol implementation designed for resource-constrained environments and bare-metal hardware. It provides a set of socket interfaces for managing reliable TCP stream connections and connectionless UDP datagrams without relying on a standard library. The project utilizes a fixed memory layout and static memory allocation to manage network state and process packets without a dynamic memory allocator. It includes specialized capabilities for low-power wireless networks, such as header compression and fragmentation for 6LoWPAN. The stack covers the data li

Mosn is a multi-protocol network proxy designed for cloud-native service meshes, API gateway management, and distributed load balancing. It forwards layer four and layer seven traffic across diverse network protocols to ensure interoperability between distributed cloud components. The project is distinguished by its ability to perform zero-downtime proxy updates, replacing the running binary while maintaining existing network connections. It further supports dynamic proxy extension, allowing custom request processing logic to be added via external plugins or compiled Go modules without restar

Nonebot2 is an asynchronous Python framework for building event-driven chatbots across multiple messaging platforms. It centers on a non-blocking event bus and a driver-based adapter system that unifies different messaging protocols into a single consistent interface. The framework utilizes a modular plugin architecture, allowing for the discovery and loading of third-party extensions to add new event handlers and system capabilities. It distinguishes itself with a type-annotation based dependency injection system that automatically resolves and provides required service objects to handlers a

VidGear is a high-performance Python video processing framework designed for capturing, transcoding, and manipulating video streams. It functions as a multi-protocol video streamer and a WebRTC streaming server, enabling the transfer of video frames over networks using RTSP, RTMP, RTP, and MJPEG protocols. The project distinguishes itself through hardware-accelerated video transcoding and decoding using GPU backends like CUDA to reduce CPU load. It includes a cross-platform screen capture tool and a specialized system for establishing direct peer-to-peer media connections using WebRTC signali

This is a self-hosted WebSocket server for Laravel applications designed to provide real-time communication and replace third-party managed messaging services. It provides a server-side PHP implementation of the WebSocket standard, enabling full-duplex communication between clients and servers. The project implements a Pusher-compatible protocol to integrate with existing frontend client libraries. It includes a dedicated debug dashboard for monitoring active connections, tracking network traffic, and analyzing real-time server performance. The system supports Laravel event broadcasting and

This project is a lightweight MQTT client library for Arduino boards, specifically designed for embedded systems utilizing an Ethernet Shield. It functions as an embedded messaging client that allows hardware devices to publish and subscribe to topics on a remote message broker. The library provides core MQTT integration, including broker connection management and the maintenance of server heartbeats. It supports topic-based message publishing and subscription management, enabling the registration of listeners to trigger functions upon message arrival. The system covers network connection co

This library is a framework for Android applications to manage Bluetooth Low Energy connectivity, peripheral discovery, and data exchange. It provides a standardized interface for integrating wireless hardware, enabling developers to handle complex communication tasks through a structured connectivity framework. The library distinguishes itself by implementing a managed operation pipeline that serializes asynchronous commands to prevent hardware collisions. It utilizes a state-machine-based approach to track connection lifecycles, which automates retry logic and maintains stable links across

Luvit is an event-driven runtime for Lua that integrates libuv to provide non-blocking I/O and asynchronous system operations. It functions as an asynchronous network framework and execution environment that leverages Just-In-Time compilation for high-performance script processing. The platform enables the distribution of network traffic across multiple CPU cores through a TCP cluster manager that shares socket handles among child processes. It provides specialized capabilities for building HTTP servers by decoding incoming request streams and encoding responses via a stream processor. The r

MassTransit is a .NET distributed application framework and asynchronous messaging library designed for building distributed systems. It serves as an enterprise service bus implementation that handles the routing, transformation, and delivery of messages between decoupled services. The framework provides a message broker abstraction layer, which decouples application code from specific messaging infrastructure such as RabbitMQ, Azure Service Bus, or Amazon SQS. It supports event-driven architecture and asynchronous microservices communication to improve system scalability and availability. T

ESPAsyncWebServer is an asynchronous web server designed for ESP32 and ESP8266 microcontrollers. It enables these devices to host websites and APIs to provide embedded device interfaces for hardware control and data display. The server utilizes non-blocking HTTP handling to process multiple concurrent network connections. This allows the device to manage web requests without pausing other background tasks or sensor readings. The implementation relies on asynchronous socket operations, event-loop request handling, and buffer-based stream parsing. It integrates directly with the network layer

Curio is a Python library for structured concurrency and asynchronous network programming. It serves as a framework for handling thousands of simultaneous TCP connections using non-blocking sockets and high-throughput I/O. The library organizes asynchronous operations into a hierarchy of parent and child coroutines to ensure reliable termination and cleanup of dependent tasks. It provides a toolkit for coordinating these concurrent operations through the use of task groups and timeouts. The framework covers a broad range of concurrency management capabilities, including inter-task communicat

Remote Desktop Control is a Java-based platform designed for remote desktop administration and system management. It enables users to access and control distant computers by streaming real-time screen imagery and relaying keyboard and mouse inputs between a controller and a target machine. The system distinguishes itself through a modular architecture that supports dynamic command handler injection and pluggable input drivers, allowing for functional extensions without modifying the core application. To ensure connectivity across restrictive firewalls and diverse network environments, the pla

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

Actix is a Rust actor framework and concurrent programming toolkit designed for building applications that manage state through an asynchronous messaging system. It provides a model where independent actors serve as autonomous units of state and logic, communicating via strongly typed messages sent to unique addresses. The framework distinguishes itself by isolating state within these actors, allowing internal data to be mutated safely during message handling without the use of locks or mutexes. It employs an asynchronous mailbox system to buffer incoming requests and uses supervision strateg