Projects sharing features with Celluloid

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

This project is a comprehensive framework for iOS application development, centered on building mobile applications that feature custom user interface components, asynchronous task management, and local data persistence. It serves as a technical knowledge base for software engineering, providing tools to organize and publish architectural analyses and notes in Markdown format. The framework distinguishes itself through a robust document-based storage layer that utilizes BSON-formatted records to perform CRUD operations within a NoSQL document store. It provides extensive system integration ca

Akka is an actor model framework and distributed systems platform used to build concurrent and distributed applications. It provides a toolkit for managing multi-threaded state and behavior through asynchronous message passing, allowing developers to create concurrent applications without manual locks or synchronization. The system functions as a cluster management and event sourcing framework, automating the scaling and coordination of high-availability clusters. It enables the deployment of elastic services that coordinate workloads across multiple network nodes and ensures fault tolerance

protoactor-go is a framework for building concurrent and distributed systems in Go using the actor model. It provides a distributed actor system that enables isolated entities to communicate via asynchronous messaging and share state across a cluster. The framework implements a multi-language actor protocol, allowing interoperability between actors written in Go, C#, and Java. It further supports a virtual actor implementation, where actors are automatically instantiated across a network based on a unique identity. The system includes a supervision model for managing actor lifecycles and fau

Akka Core is an actor model framework and asynchronous concurrency library used for building scalable and resilient distributed systems. It provides a distributed computing platform and fault tolerant runtime that manages communication and state across networked nodes. The system uses location-transparent messaging and a cluster management system to organize nodes into high-availability architectures. This allows for the creation of elastic clusters that scale resources on demand and coordinate distributed workloads. The platform handles concurrent state management and distributed systems or

This project serves as a comprehensive educational repository and technical reference collection, documenting a wide range of software engineering practices and modern development technologies. It provides a structured learning path for developers, curating tutorials and practical examples that cover the full lifecycle of application development, from initial project scaffolding to deployment and maintenance. The repository distinguishes itself by offering deep technical insights into complex architectural patterns, including actor-based concurrency models for managing parallel tasks and cont

Lnd is a full implementation of the Lightning Network protocol, functioning as a Bitcoin Layer 2 daemon that manages payment channels and settles transactions on the Bitcoin blockchain. It serves as an off-chain payment processor and a cryptographic wallet manager, enabling the execution of instant, scalable transactions through a network node. The project distinguishes itself through a focus on secure node networking and programmatic control. It provides gRPC and REST API servers for automating payment workflows and utilizes macaroon-based authorization to delegate granular permissions via c

coobjc is an Objective-C coroutine library that provides await methods and generators to simplify asynchronous programming in Objective-C and Swift. It enables the implementation of non-blocking workflows to eliminate nested callbacks and thread blocking. The toolkit includes a non-blocking Foundation wrapper to convert synchronous Foundation and UIKit APIs into suspendable operations. It provides a lazy sequence generator for producing values on demand via yield, as well as a channel-based communication tool for exchanging data between concurrent tasks using buffered and unbuffered channels.

OTP is a concurrent programming framework and distributed computing platform that serves as the Erlang runtime environment. It provides a fault-tolerant operating environment designed for building scalable, real-time systems that manage massive amounts of simultaneous tasks through asynchronous messaging. The environment is distinguished by its use of an actor-based concurrency model and hierarchical supervision trees that automatically restart failed processes. It supports hot code loading to allow system updates without downtime and utilizes a preemptive user-space scheduler to manage light

ejabberd is a multi-protocol communication gateway and scalable server that implements XMPP for instant messaging and presence. It serves as a federated messaging platform, enabling interoperable communication and user discovery between different remote servers. The project functions as an MQTT message broker for lightweight IoT device communication and a SIP signaling server for managing voice and multimedia signaling traffic. It allows for the hosting of multiple domains on a single instance using virtual hosting to isolate configurations and prevent username conflicts. The system provides

Actix Web is an asynchronous web framework designed for building high-performance network services. It provides a foundation for processing concurrent requests through a non-blocking execution model, utilizing an actor-based concurrency system to manage lightweight processes and message passing. The framework includes a low-level networking layer that handles the parsing and serialization of HTTP traffic according to standard specifications. The framework distinguishes itself through a type-safe routing engine that enforces strict data types at compile time, ensuring that request parameters a

This project is a high-performance MQTT broker and IoT data platform designed to manage millions of concurrent device connections. It provides a scalable infrastructure for ingesting, processing, and routing telemetry data across distributed systems, utilizing an actor-based concurrency model to maintain high availability and state synchronization across cluster nodes. The platform distinguishes itself through integrated stream processing and edge computing capabilities. It allows users to execute declarative SQL-based rules directly against incoming message streams for real-time filtering, t

Lila is a comprehensive, open-source chess gaming platform designed for real-time multiplayer interaction, competitive tournament management, and deep strategic analysis. It provides a global environment where users can engage in live matches, participate in structured competitions, and access extensive archives of historical game data for research and study. The platform distinguishes itself through a highly scalable architecture that utilizes actor-model concurrency and event-sourced game states to ensure precise match reconstruction and fault tolerance. It integrates distributed engine eva

The Dart SDK is a comprehensive development kit for building cross-platform applications using a multi-paradigm programming language. It provides a unified toolchain that supports both just-in-time compilation for rapid development and ahead-of-time compilation for high-performance native machine code. The platform is built on a sound static type system and an isolate-based concurrency framework, which executes independent tasks in separate memory heaps to achieve parallelism without shared state contention. The SDK distinguishes itself through a versatile compilation pipeline that transforms

This project is a functional programming library and toolkit for building production TypeScript applications. It provides a system for managing concurrency, error handling, and resource lifecycles using functional effects. The project distinguishes itself through a comprehensive suite of specialized toolkits, including a dependency injection framework for decoupling service implementations, a workflow orchestrator for coordinating durable processes, and a SQL database toolkit for consistent data operations across multiple dialects. It also implements an OpenTelemetry instrumentation library f

Parallel is a Ruby library and multi-process execution framework designed to accelerate CPU-intensive operations. It functions as a parallel job orchestrator and concurrent task runner that enables the execution of code across multiple processes or threads. The project distinguishes itself through secure inter-process communication, utilizing signed data serialization to prevent the injection of forged payloads between parent and child processes. It further differentiates its worker management by assigning unique identifiers to individual processes to prevent collisions when accessing shared

NoahGameFrame is a distributed game server framework designed for real-time multiplayer games. It utilizes an actor model backend to manage game state and logic through an asynchronous, event-driven system that distributes workloads across multiple CPUs. The framework features a scriptable server environment that integrates external scripting languages, allowing for updates to game behavior and mechanics without restarting the server. It also employs a plugin-based architecture with an interface-oriented design to enable the addition of custom application logic and modular engine extensions.

Wren is an embeddable, class-based scripting language and bytecode interpreter. It provides a dependency-free virtual machine designed for integrating dynamic script execution into host applications via a C API. The language is centered on a modern object-oriented model featuring inheritance, method overloading, and first-class functions. It utilizes a concurrent fiber runtime to manage lightweight, cooperatively scheduled execution paths without relying on operating system threads. The project includes a comprehensive suite of object-oriented primitives, closure-based state capture, and a m

Wren is a bytecode-compiled, class-based scripting language designed as an embeddable programming language. It provides a lightweight runtime and interface for executing dynamic scripts directly within host software applications. The engine utilizes a single-pass compiler to transform source code into compact bytecode and a virtual machine to process those instructions. It supports concurrent task execution through a system of lightweight fibers and coroutines. The language implements a class-based object model with dynamic message dispatch for organizing code into reusable components. It al

XState is a statechart logic library and finite state machine framework used to model complex application behavior. It provides a system for defining states, events, and transitions to govern how a system responds to inputs through a formal schema. The project includes a visual state machine editor that allows for the design of state machine diagrams which automatically generate the corresponding logic and code. It implements an actor model to manage independent concurrent entities that communicate via asynchronous events to coordinate behavioral flows. The framework covers event-driven stat

This project is a reference implementation of a production-ready backend API built with Rust and the Actix-Web framework. It serves as a codebase demonstrating the development of a newsletter subscription service, encompassing the management of subscriber sign-ups, email confirmations, and campaign delivery. The project highlights a layered architecture that separates concerns into handler, service, and repository layers. It utilizes an actor-based concurrency model for handling HTTP requests and employs trait-based abstractions to decouple business logic from external dependencies, such as e

Red is a programming language with a native compiler that translates high-level source code into standalone executables for Windows, macOS, and Linux without external runtime dependencies. It combines a cross-platform GUI development framework that renders native operating system widgets from a single codebase with a reactive data binding system that automatically synchronizes UI state with data sources. The language also includes an embedded DSL and parsing engine based on PEG grammar rules for defining and processing domain-specific languages within the language itself. The project distingu

Play is a full-stack reactive web framework for Java and Scala. It provides a comprehensive development platform for building scalable web applications and RESTful APIs using a stateless and non-blocking architecture designed for high concurrency. The framework emphasizes high-velocity development through dynamic code reloading, which allows developers to update applications and verify changes without performing a full restart. Its capability surface covers the construction of JSON-based web endpoints, server-side logic for the JVM, and the implementation of scalable web architectures.

Commanded is an Elixir framework designed for building event-sourced applications that utilize domain-driven design. It provides a structured environment for implementing command-query responsibility segregation, allowing developers to separate write-side command processing from read-side data projection. By treating state changes as an immutable sequence of events, the framework ensures a reliable audit trail and facilitates system recovery. The project distinguishes itself through its support for distributed process orchestration and event-driven middleware pipelines. It enables the managem

ProxyManager is a JavaScript proxy wrapper library and object-oriented utility for intercepting and modifying object behavior. It functions as an object behavior interceptor that wraps target objects to monitor, restrict, or modify method calls and property access at runtime. The library provides mechanisms for lazy initialization and lazy loading, deferring the creation of resource-heavy objects until a property or method is first accessed to reduce memory overhead. It uses an object-oriented structure to manage these proxy wrappers and their associated target objects. The tool covers capab

cglib is a suite of tools for JVM bytecode generation, class transformation, and dynamic proxying. It provides a high-level API for creating and transforming Java bytecode at runtime to modify class behavior and a framework for intercepting method calls and field access. The project implements dynamic proxy generation to support aspect oriented programming and custom data access patterns. It also includes a serialization manager to implement serialization contracts by adding specific methods and controlling object replacement within proxy classes. The library covers bytecode manipulation and