Haskell Concurrency

A Haskell library that simplifies access to remote data, such as databases or web-based services.

High performance, streaming and concurrent functional programming in Haskell

Run IO operations asynchronously and wait for their results

Systematic concurrency testing meets Haskell.

Systematic concurrency testing meets Haskell.

The LVish Haskell library

A collection of different packages for CAS based data structures.

A haskell library implementing fast and scalable concurrent queues for x86, with a Chan-like API

Cached and parallel data fetching.

lifted IO operations from the threads library

A structured concurrency library

Model-view-controller

Containers for STM

Concurrent PostgreSQL data consumers

OTP-like supervision trees in Haskell

Concurrency for the pipes ecosystem

STM-based channels for conduits.

A work stealing scheduler

...

Interactive-diagrams

The library FDR3 uses for parsing, type checking and evaluating machine CSP.

Run lifted IO operations asynchronously and wait for their results

The library FDR3 uses for parsing, type checking and evaluating machine CSP.

DISCONTINUED. Async combinators

Fork threads and wait for their result

DISCONTINUED. Distributed, stateful, homogeneous microservice framework.

Safe, programmable, speculative evaluation for Haskell

Spawn threads that never die (unless told to do so)

Simple, IO-based Haskell library for Erlang-inspired thread supervisors

lazy promises

Extra utilities for STM queues

Concurrency features for the Haskell machines package

Extra concurrency primitives

A fast globally unique variable supply with a pure API

File locking

A principal solution to ghost threads and silent exceptions

STM-specialised Hash Array Mapped Trie

Sirkel; a Chord DHT in haskell. Node failure, replication and batteries included!

Incubator for my Haskell libraries

A fast, cache-efficient, concurrent bloom filter in Haskell

Non-blocking concurrent hashmap for Haskell

Unbounded thread delays and timeouts

A simplified implementation of Erlang/OTP like supervisor for GHC thread

A thread-safe hash table in Haskell

Simple package that implements timers. Both "one-shot" and "repeating" timers are implemented.

Control.Concurrent.Chan split into sending and receiving halves.

Concurrent and combinable updates

Haskell rate limiter library using lazy token bucket algorithm

fast unique variables

Bounded channels with invalidating readers

A Haskell library providing an idiomatic implementation of the actor model of concurrency

Simple thread management

A contention-free STM hash map for Haskell

DISCONTINUED. Loop over an action but throttle it to a certain rate

A very simple interface for incremental computation using STM in Haskell.

A utility for concurrent programming in Haskell, insipired by Ticker in golang.

Implicit monadic dataflow parallelism

Unagi-chan channels for io-streams.

Generalized sleep and timeout functions

Can we realize Rust's ownership model as a monad in Haskell?

Concurrently + Either

Go-style channels for Haskell (WIP)

SafeSemaphore is a Haskell library replacing non-exception safe libraries like QSem, QSemN, SampleVar

Fast rate limiting for Haskell using the token bucket algorithm. BSD-licensed.

Provides access to GHC's dynamic pointer tag bits

A monadic interface for async

Periodic timers based on async API.

Throttler between a producer and a consumer function

Allows timeouting a computation while allowing it to return partial results. Useful for making AI-like algorithms that should return the best result found within a time limit.

Bounded (limited capacity) channels for Haskell

A tiny Haskell library for concurrent computations

Updatable timeouts as a Monad transformer

Limit number of IO actions started per second

Simple Haskel thread management in hierarchical manner

DISCONTINUED. set a maximum on the number of concurrent actions

Baisc, Erlang-like message passing for Haskell.

Fast concurrent queues much inspired by unagi-chan

Transactional I/O for duplex streams

Build a Queue-Processing Worker Pool using Immortal

Haskell: Synchronize multiple actions to be triggered as parallel as possible

DISCONTINUED. DEPRECATED - Stream data to and from subprocesses using Pipes

simple and general quantity semaphores in ghc haskell

utility for collapsing adjacent writes

Minimalistic actor library for Haskell

A simple round-robin data type

Extra utilities for async

A simple implementation of a multiple-reader / single-writer locks using STM

A message passing concurrency extensible-effect

Practical actors for Haskell.

Simple package that allows for long thread suspensions. Uses newtype wrapper (of Int64 at the moment) to represent delay.

Output from parallel subprocesses is an ugly, many-headed beast. Piping though hydra-print provides a NCurses interface to a dynamic set output streams, displayed without interleaving.

Simple and fast implementation of Future

Haskell: Various concurrent combinators

Thread delay and timeout functions with typed arguments

Implementation of skip variables (a special case of skip channels)

GHC STM's TChan split into sending and receiving halves.

Thread communication queues that group items/requests that occur close together in time

Bundles shared calls to IO functions to perform them only once

Hactor is a rewrite of thespian, a library which aims to provide lightweight Erlang-style actors for Haskell.

Haskell channels with the forwarding primitive