Open-source alternatives to Cpp Rotor

ArrayFire is a hardware-agnostic compute framework and JIT-compiled tensor engine designed for high-performance numerical computing. It serves as a GPU numerical computing library and parallel signal processing toolkit that abstracts hardware backends, allowing the same codebase to execute across various GPU architectures and CPUs. The project distinguishes itself through a JIT engine that uses expression compilation to fuse operations and minimize memory overhead. It employs a deferred execution graph to optimize computation chains and provides interoperability primitives to share data and e

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.

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

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

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

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

A task scheduling framework designed for the needs of game developers.

brain-dead simple parallel processing for ruby