Open-source alternatives to Coros

Cancellation propagation library for Common Lisp with deadlines and timeouts

Run etcd as an asynchronous inferior process

A full-featured NATS messaging client for Common Lisp.

Event loop friendly C++ actor micro-framework, supervisable

Powerful multi-threaded coroutine dispatcher and parallel execution engine

A header-only C++ library for task concurrency

A C++ GPU Computing Library for OpenCL

Reactive computation tree library for non-blocking concurrent Common Lisp

Common Lisp distributed computation framework implemented using Swank Client

C++11 thread-safe container for sharing data between threads (synchronized queue)

ConcurrentQueue is a header-only C++ template library that provides a lock-free data structure for multi-producer multi-consumer thread communication. It functions as a synchronization primitive designed to coordinate data flow between concurrent execution units using atomic operations rather than traditional mutex locking. The library distinguishes itself through a design that minimizes contention and synchronization overhead. It utilizes sub-queue token mapping to distribute workloads across partitioned internal queues and supports bulk operations to transfer multiple data elements in singl

This project is a single-producer single-consumer concurrent queue for C++ designed for lock-free data exchange between threads. It provides a thread-safe mechanism to transfer data without the use of mutexes or locks. The queue is implemented as a contiguous circular buffer that supports dynamic capacity growth to prevent data loss when the queue reaches its limit. It utilizes atomic synchronization and wait-free index management to coordinate data access between the writing and reading threads. The library covers inter-thread communication and buffer management, offering both blocking and

The project alpaka has moved to https://github.com/alpaka-group/alpaka

The project alpaka has moved to https://github.com/alpaka-group/cupla

Concurrency primitives, safe memory reclamation mechanisms and non-blocking (including lock-free) data structures designed to aid in the research, design and implementation of high performance concurrent systems developed in C99+.

A bleeding-edge, lock-free, wait-free, continuation-stealing tasking library built on C++20's coroutines

High performance Transactional Memory for Common Lisp

Modern concurrency for C++. Tasks, executors, timers and C++20 coroutines to rule them all

VexCL is a C++ vector expression template library for OpenCL/CUDA/OpenMP

Fine-grained concurrency for Ruby

EventMachine is a reactor-pattern network framework for Ruby that provides an asynchronous I/O library for performing non-blocking network and file operations. It functions as a network server framework used to build scalable TCP and UDP servers and clients that process multiple simultaneous requests. The framework implements a concurrency model that dispatches network events to registered handlers using a single-threaded event loop. This approach allows for the management of high-concurrency network connections without the overhead of multi-threaded programming. The library covers the devel

Thin, unified, C++-flavored wrappers for the CUDA APIs

The project provides high-performance concurrency, enabling highly parallel computation.

Background job processing for Common Lisp

brain-dead simple parallel processing for ruby