Projects sharing features with Transwarp

The C++ Standard Library for Parallelism and Concurrency

Kokkos C++ Performance Portability Programming Ecosystem: The Programming Model - Parallel Execution and Memory Abstraction

Concurrent data structures in C++

JCTools is a Java concurrency library providing a collection of lock-less and wait-free data structures. It serves as a toolkit for managing thread-safe data exchange, specifically designed to optimize high-throughput messaging and producer-consumer patterns in multi-threaded applications. The library distinguishes itself by implementing specialized queue structures that minimize contention and maximize throughput. By utilizing techniques such as cache-line padding, memory-barrier-based synchronization, and relaxed-consistency memory ordering, it avoids the performance bottlenecks often assoc

This project is a structured Rust programming curriculum and systems programming course designed to take learners from beginner to expert levels. It provides a comprehensive set of training materials focused on mastering the core syntax, idioms, and technical foundations of the Rust language. The project features a specialized language transition framework that maps concepts from C++, managed languages, and dynamic typing to Rust idioms. This allows developers from different ecosystems to translate architectural patterns and memory models into idiomatic Rust. The training covers a broad rang

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

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

A full-featured NATS messaging client for Common Lisp.

Powerful multi-threaded coroutine dispatcher and parallel execution engine

A C++ GPU Computing Library for OpenCL

Async++ concurrency framework for C++11

brain-dead simple parallel processing for ruby

Run etcd as an asynchronous inferior process

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

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

Cancellation propagation library for Common Lisp with deadlines and timeouts

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

Cpp-taskflow is a C++ task-parallelism framework and task graph scheduler designed to manage and execute complex dependency graphs of parallel tasks across CPU and GPU hardware. It provides a parallel algorithm library for high-performance implementations of reductions, sorts, pipelines, and iterations. The framework distinguishes itself through its ability to offload heavy computational workloads from a task graph to graphics processors for acceleration. It also includes a task profiling tool and a performance analysis interface for visualizing task execution flow and dependency structures t

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

alpaka - Abstraction Library for Parallel Kernel Acceleration

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

A modern, fast, lightweight thread pool library based on C++2x

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