Open-source alternatives to STEllAR GROUP Hpx

The libdispatch Project, (a.k.a. Grand Central Dispatch), for concurrency on multicore hardware

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

brain-dead simple parallel processing for ruby

A full-featured NATS messaging client for Common Lisp.

Run etcd as an asynchronous inferior process

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

Powerful multi-threaded coroutine dispatcher and parallel execution engine

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

A C++ GPU Computing Library for OpenCL

Async++ concurrency framework for C++11

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

BS::thread_pool: a fast, lightweight, modern, and easy-to-use C++17 / C++20 / C++23 thread pool library

Cancellation propagation library for Common Lisp with deadlines and timeouts

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

A framework for writing RDMA applications with high-level abstraction and asynchronous APIs.

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

Common Lisp distributed computation framework implemented using Swank Client

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

Reactive computation tree library for non-blocking concurrent Common Lisp