Open-source alternatives to Coobjc

pysheeet is a technical reference library providing a curated collection of code snippets and implementation patterns for advanced Python development, system integration, and high-performance computing. It serves as a comprehensive guide for implementing low-level network programming, native C extensions, and asynchronous and concurrent programming. The project provides specialized frameworks for the development and deployment of large language models, including tools for distributed GPU inference and high-performance serving. It also includes detailed patterns for high-performance computing

Gevent is a Python coroutine concurrency library and asynchronous task manager designed for high-concurrency I/O tasks. It provides a cooperative networking framework for building asynchronous TCP, UDP, and HTTP servers, as well as a WSGI web server implementation for hosting web applications. The project is distinguished by its standard library monkey-patching tool, which replaces blocking synchronous functions with cooperative versions to enable asynchronous behavior in third-party code. This allows for a cooperative multitasking workflow where the system yields execution during I/O waits t

This repository is a collection of JavaScript coding challenges and a comprehensive interview guide. It provides reference implementations and educational examples designed to help developers master language fundamentals and prepare for technical interviews. The project covers a wide array of specialized implementations, including functional programming patterns like currying and partial application, as well as asynchronous patterns for concurrency control. It also includes practical examples of Document Object Model manipulation and the implementation of common data structures such as stacks

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

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

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 is a C++ ranges library and extension to the Standard Template Library that provides a collection of composable algorithms and lazy views for processing data sequences. It functions as a lazy sequence processing framework and a template meta-programming library for manipulating type lists and performing compile-time type computations. The project enables functional programming patterns in C++ through the use of pipe syntax and partial application to create readable, left-to-right data transformation chains. It allows for the construction of lazy data pipelines that filter and transform e

Lazy.js is a JavaScript library that implements a lazy evaluation model for processing collections and data streams. It defers all computation until iteration begins, building chains of transformations that execute only when values are consumed, avoiding intermediate arrays and buffering. The library wraps data sources into a uniform sequence interface, enabling operations like map and filter to be chained together without materializing intermediate results. The library extends lazy processing beyond simple collections to handle asynchronous data sources, DOM events, strings, and Node.js stre

Yo is a Node.js CLI framework and project template orchestrator used to automate the creation of standardized software projects. It functions as an interactive project generator and scaffolding runner that produces customized source code and manifests based on user input and predefined templates. The system utilizes a plugin-based architecture to discover and execute external setup tools. It distinguishes itself through a memory-first file system that resolves conflicts before committing changes to disk and a priority-queue task orchestration model to ensure the correct execution order of com

Pony is an open-source, actor-model, capabilities-secure, high performance programming language

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

language-ext is a functional programming framework for C# that provides a suite of immutable data structures and monadic types. It enables the implementation of pure functional programming patterns, utilizing containers to manage side effects, optional values, and error handling. The library is distinguished by its advanced concurrency and state management tools, including a software transactional memory system and lock-free atomic references. It also provides specialized utilities for distributed systems, such as vector clocks for causality tracking and deterministic data conflict resolution

Janet is a Lisp-based dynamic programming language featuring a register-based bytecode virtual machine and an embeddable scripting engine. It functions as a fiber-based concurrency runtime and includes a parsing engine based on Parsing Expression Grammars. The project is distinguished by its ability to be integrated into C or C++ applications via a minimal header interface. It utilizes a Lisp-style macro system for compile-time code transformation and employs prototype-based table inheritance for object-oriented behavior. The runtime covers a broad set of capabilities, including asynchronous

ES6-for-humans is an educational resource and technical manual providing a structured tutorial and programming guide for the ECMAScript 2015 language standards. It serves as a reference for transitioning from legacy JavaScript to modern syntax and coding patterns. The project covers modern language constructs including block-scoped variables, arrow functions, and class hierarchies. It provides guidance on implementing functional programming patterns via generators and lexically scoped functions, as well as object-oriented design using prototype-based inheritance. The documentation covers asy

LuaJIT is a high-performance Lua language implementation and just-in-time compiler. It functions as an embedded scripting engine and dynamic binary translator that converts portable bytecode into native machine code during execution. The project focuses on high-performance scripting by translating bytecode into architecture-specific instructions to achieve execution speeds close to compiled C code. It utilizes a lightweight runtime environment designed for minimal memory overhead. The system supports binary data processing via bitwise operations and enables asynchronous task management throu

Async is a JavaScript asynchronous flow library designed to manage the execution and coordination of asynchronous tasks in Node.js and the browser. It provides functional utilities to wrap, process, and orchestrate complex asynchronous workflows. The library distinguishes itself through a comprehensive task orchestrator that handles dependency graphs to resolve circular references and manages concurrent task queues. It includes a unification bridge that allows callback-style and promise-based functions to operate within the same execution interface. The project covers several primary capabil

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 framework for building concurrent, event-driven applications in Ruby. It provides a core engine that orchestrates non-blocking input and output operations, allowing developers to handle high-volume network traffic and system tasks without the complexity of traditional callback-based programming. By leveraging lightweight fibers, the library enables cooperative multitasking that maintains responsiveness during heavy data processing workloads. The framework distinguishes itself through a structured concurrency model that organizes tasks into parent-child hierarchies. This appr

Oils is a Unix shell interpreter and scripting language runtime that combines a modern shell language with POSIX and Bash compatibility. It functions as a structured data shell, integrating JSON and J8 formats to manage complex data without relying on string parsing. The system is distinguished by a C++ transpiled interpreter that converts a subset of Python source code into strongly typed C++ for high-performance execution. It features a garbage-collected typed runtime that supports prototype-based polymorphism, lexical closures, and reference-based variable mutation. To decouple shell logic

fp-ts is a TypeScript library that brings pure functional programming patterns to the language through algebraic data types, type class abstractions, and composable combinators. It provides foundational data types like Option for optional values, Either for typed error handling, and Task for lazy asynchronous computations, all designed to make invalid states unrepresentable and side effects explicit. The library is built on category theory concepts, offering type classes such as Functor, Applicative, Monad, Semigroup, and Monoid with lawful instances for common data structures. The library di

This project is a comprehensive Lisp AI implementation library that provides reference implementations for various artificial intelligence paradigms and symbolic algorithms. It functions as a multi-purpose toolkit containing a logic programming engine, a natural language processing suite, and a symbolic mathematics toolkit. The library is distinguished by its diverse architectural frameworks, including a Prolog-style execution engine that uses unification and goal-driven backtracking, and a system for simulating human decision-making through expert system shells and certainty factors. It also

Celluloid is a concurrent object framework for the Ruby language. It implements the actor model to enable the construction of multithreaded programs where objects communicate through asynchronous message passing to avoid shared state locks. The framework provides a system for managing asynchronous interactions without manual locking or thread management. It utilizes actor-based object orientation to handle parallel execution and non-blocking tasks. The project covers several architecture and capability areas, including mailbox-driven execution, fiber-based task scheduling, and proxy-based me

Bolts-Android is a mobile development library for Android that provides a framework for deep-linking and a system for managing asynchronous tasks. It functions as a toolkit for parsing inbound intents, resolving URL metadata, and routing users to specific native content within an application. The library includes a task manager for coordinating parallel background operations and handling thread-safe execution. This system uses chainable tasks, cancellation tokens to stop active processes, and routing to ensure results return to the main user interface thread. The framework also covers deep-l

PromiseKit is a future-based concurrency framework and promise library for Swift and Objective-C. It functions as an asynchronous workflow coordinator, representing the eventual result of an operation to simplify concurrency logic and replace nested callback structures. The framework enables the coordination of both sequential and parallel asynchronous tasks. It provides a structured pipeline for chaining operations, allowing the results of one task to be passed into the next and facilitating the execution of multiple operations simultaneously. The library includes a state-machine based reso

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

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

Amp is a non-blocking concurrency framework for PHP. It provides a core infrastructure for writing asynchronous applications using an event loop to schedule operations, timers, and signals within a single process. The project implements a coroutine library that utilizes fibers to suspend and resume function execution. This allows the system to handle concurrent tasks without blocking the main execution thread, optimizing CPU usage during input and output operations. It further manages pending operation results through a future and promise implementation. The framework covers a broad range of