Open-source alternatives to Kraken Php Framework

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

Kore is an event-driven web and WebSocket server framework designed for building high-performance web services and APIs in C or Python. It functions as a secure, concurrent application framework that utilizes non-blocking I/O and isolated worker processes to handle high-concurrency traffic. The project is distinguished by a security-first architecture that features OS-level process sandboxing, privilege separation, and the isolation of private encryption keys into dedicated processes. It enables zero-downtime deployments through dynamic module hot-reloading and provides automated TLS certific

This project is a PHP implementation of the Promises/A+ specification, providing a library for managing asynchronous operations and deferred values. It serves as an asynchronous task coordinator that allows for the creation of non-blocking code through a promise-based pattern. The library enables the simulation of asynchronous coroutines, allowing non-blocking code to be written in a linear style. It features duck-typed interoperability, which allows it to integrate with any foreign object that implements a then method regardless of class inheritance. The project covers broader capabilities

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

EasySwoole is a high-performance asynchronous PHP framework designed for building event-driven networks and persistent memory applications. It functions as a toolkit for developing distributed microservices and asynchronous servers capable of handling concurrent HTTP, TCP, UDP, and WebSocket connections. The framework distinguishes itself through a persistent memory process execution mode that eliminates the overhead of repetitive file loading and invocation during request handling. It provides built-in support for distributed systems via remote procedure call implementations and service disc

Akka.NET is an actor model framework used for building concurrent and distributed applications. It functions as a distributed computing platform and state manager that enables isolated actors to communicate via asynchronous message passing, ensuring thread-safe state management without manual locks. The project is distinguished by its decentralized coordination capabilities, including a distributed state manager that uses sharding and dynamic rebalancing to maintain high availability. It incorporates an event sourcing engine that persists state as a sequence of events in an append-only log an

libwebsockets is an event-driven networking framework written in C. It provides a suite of tools for implementing HTTP servers and clients, WebSocket bidirectional communication, MQTT client messaging, and TLS-enabled socket encryption. The project distinguishes itself through a non-blocking event-loop architecture capable of scaling to high connection volumes by distributing network sessions across multiple service threads. It uses a protocol-based callback system and a pluggable event loop integration that allows the networking core to synchronize with external system event libraries. The

ET is a C# game server framework and distributed actor model runtime designed for large-scale multiplayer environments. It provides a comprehensive toolkit for building distributed game backends, incorporating a multiplayer network transport layer and a specialized suite for game AI and pathfinding. The framework is distinguished by its use of a distributed actor model to scale processing across multiple threads and servers, utilizing isolated actors for state management and messaging. It features a unified codebase architecture that allows shared logic between the server and client, enabling

Dragonboat is a Go implementation of the Raft consensus protocol designed to maintain consistent state across a distributed cluster of nodes. It provides a library for building distributed state machines that ensure data integrity and fault tolerance during system failures. The project distinguishes itself through a multi-group Raft implementation, which partitions data across independent consensus groups to distribute workloads and increase overall system processing capacity. It also incorporates mutual TLS to encrypt inter-node communication and verify the identity of cluster members. The

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

Ratchet is a PHP library for building asynchronous WebSocket servers that handle persistent, bidirectional communication between clients and the server. It provides a complete server-side WebSocket implementation, including protocol handshake negotiation, message framing over TCP, and an event-loop-based concurrency model that manages thousands of simultaneous connections without blocking. The library implements a connection registry pattern for tracking all active WebSocket sessions, enabling the server to broadcast or unicast messages to any connected client on demand. It relies on non-bloc

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

InternetArchitect is an educational collection of documents and source code designed as a high concurrency architecture course. It serves as a distributed systems implementation guide, providing technical patterns and practical examples for designing scalable internet architectures that maintain stability under heavy traffic loads. The project focuses on high-performance database optimization and microservices design patterns. It covers strategies for reducing latency and increasing throughput via database sharding and proxy layers, as well as coordinating global state across distributed clus

This project serves as a comprehensive technical reference for the architecture and design of data-intensive applications. It provides a structured analysis of the fundamental principles required to build reliable, scalable, and maintainable software systems, covering the core trade-offs inherent in modern data infrastructure. The repository explores the mechanics of distributed data management, including strategies for replication, partitioning, and achieving consensus across multiple nodes. It details the design of storage engines, indexing techniques, and transaction management models, whi

Leaf is a game server framework written in Go designed for building multiplayer game backends. It provides a modular backend architecture that organizes server logic into independent modules and includes a concurrent task scheduler for managing ordered, delayed, or recurring functions. The framework features a TCP and WebSocket server that manages simultaneous connections through a single interface. It incorporates a message router capable of decoding Protobuf and JSON data to map incoming network packets to specific internal server modules. The system includes capabilities for multi-protoco

Concurrent Ruby is a comprehensive concurrency toolkit for the Ruby language that provides thread-safe data structures, synchronization primitives, and asynchronous execution patterns. It implements core concurrency abstractions including an actor model framework where isolated actors communicate through asynchronous message passing, a future and promise system for composing non-blocking operations, and thread pool executors that manage reusable worker threads for concurrent task execution. The library distinguishes itself through a broad set of coordination mechanisms that go beyond basic th

This library provides a framework for building event-driven, non-blocking network applications in PHP. It enables the development of asynchronous TCP and TLS servers and clients that manage multiple concurrent connections without stalling the main execution thread. By utilizing an event-loop architecture, the library handles network operations and data exchange through asynchronous streams, ensuring that the application remains responsive during high-throughput tasks. The project distinguishes itself through its integration with operating system primitives, such as raw file descriptors and Un

Drogon is a high-performance, cross-platform C++ framework designed for building asynchronous web services and server-side applications. It functions as a multi-threaded, event-driven server engine that manages concurrent network traffic and WebSocket connections with minimal latency. By leveraging non-blocking input/output and native code compilation, the framework provides a foundation for scalable applications that operate efficiently across diverse hardware architectures. The framework distinguishes itself through its compile-time template rendering, which transforms dynamic HTML views in

This project is a frontend development blog and technical knowledge base. It serves as a software engineering reference and web development portfolio, providing a curated collection of articles and notes on front-end engineering, programming patterns, and computer science fundamentals. The site focuses on frontend engineering education and technical knowledge management. It covers software architecture patterns, web development workflows, and engineering interview preparation through the organization of technical guides and tutorials. The project's scope includes the documentation of browser

This project is a comprehensive reference guide and technical documentation for the features, syntax updates, and APIs introduced in ECMAScript 6. It serves as a language specification and overview for modern JavaScript development. The guide covers a wide range of language enhancements, including the implementation of classes and prototype-based inheritance, the use of arrow functions for lexical scope binding, and the introduction of block-scoped variables. It details the module system for organizing independent code components via import and export statements. The documentation extends to

Ockam is a zero-trust networking framework designed to secure data transit between distributed applications using an identity-based network overlay. It provides the primitives necessary to establish mutually authenticated and end-to-end encrypted connections, removing the reliance on traditional network-layer security. The project is distinguished by its use of attribute-based access control and verifiable credentials to manage trust at scale. It implements cryptographic identity rotation to maintain identity continuity and integrates with hardware-backed key management systems to secure priv

Bolts-Swift is a concurrency control framework designed to manage asynchronous workflows in native mobile applications. It provides a collection of primitives that allow developers to orchestrate background operations through a promise-based model, replacing deeply nested callback structures with chainable task sequences. The library distinguishes itself by offering granular control over task lifecycles and execution environments. It enables developers to define custom executors for specific threading contexts and provides mechanisms to manually signal the completion, error, or cancellation o

This project is a curated collection of Android development code snippets, implementation patterns, and technical guides designed to assist in building and maintaining mobile applications. It serves as a reference for standard mobile architecture, providing structured approaches to common development requirements and system integration tasks. The repository distinguishes itself by offering specific technical strategies for managing application lifecycles, optimizing memory usage, and ensuring interface responsiveness in resource-constrained environments. It provides programmatic techniques fo

This project is an embedded operating system for creating decentralized peer-to-peer communication networks using long-range radio hardware. It provides an off-grid messaging protocol for transmitting text and GPS coordinates without relying on cellular or internet infrastructure. The firmware implements a secure communication framework using shared keys and high-grade encryption to protect data transmitted over the air. It includes a LoRaWAN hardware interface to manage radio parameters and an MQTT radio gateway to bridge local mesh traffic to external networks. The system covers a broad ra

This project is a remote file transfer server and asynchronous download orchestrator. It functions as a backend service that manages a queue of remote file transfer requests to coordinate the download of files from the web to a remote storage destination. The system operates as a distributed download coordinator, scheduling and tracking the progress of file transfers across different network nodes. It routes data requests from a client to a remote file system and utilizes asynchronous task execution to process heavy file operations in the background. The server includes capabilities for queu

Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for cloud-native environments. The framework distinguishes itself through a unified approach to reactive and imperative program

An asynchronous I/O and reactor event loop library for PHP, this project provides core primitives for coordinating non-blocking operations, managing system resources, and scheduling background tasks. The runtime executes concurrent operations by continuously running tick-based loop iterations that process pending timers, network streams, deferred callbacks, and system signals through efficient system-level polling mechanisms. The library coordinates event-driven execution using asynchronous timers for one-off or periodic tasks, next-tick deferred execution for breaking down workloads, and str