Haskell Concurrency

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

High performance, concurrent functional programming abstractions

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

Model-view-controller

lifted IO operations from the threads library

Cached and parallel data fetching.

A structured concurrency library

Containers for STM

Concurrency for the pipes ecosystem

OTP-like supervision trees in Haskell

Concurrent PostgreSQL data consumers

STM-based channels for conduits.

A work stealing scheduler

...

Run lifted IO operations asynchronously and wait for their results

Interactive-diagrams

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

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

DISCONTINUED. Async combinators

Fork threads and wait for their result

Safe, programmable, speculative evaluation for Haskell

DISCONTINUED. Distributed, stateful, homogeneous microservice framework.

lazy promises

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

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

Extra utilities for STM queues

Concurrency features for the Haskell machines package

A fast globally unique variable supply with a pure API

Extra concurrency primitives

A principal solution to ghost threads and silent exceptions

File locking

STM-specialised Hash Array Mapped Trie

Incubator for my Haskell libraries

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

Haskell rate limiter library using lazy token bucket algorithm

Unbounded thread delays and timeouts

Concurrent and combinable updates

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

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

Non-blocking concurrent hashmap for Haskell

fast unique variables

A thread-safe hash table in Haskell

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

Bounded channels with invalidating readers

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

Simple thread management

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

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

Unagi-chan channels for io-streams.

Provides access to GHC's dynamic pointer tag bits

A contention-free STM hash map for Haskell

Concurrently + Either

A monadic interface for async

Go-style channels for Haskell (WIP)

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

Bounded (limited capacity) channels for Haskell

Implicit monadic dataflow parallelism

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

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

Generalized sleep and timeout functions

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

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.

Periodic timers based on async API.

Throttler between a producer and a consumer function

A tiny Haskell library for concurrent computations

Updatable timeouts as a Monad transformer

Extra utilities for async

simple and general quantity semaphores in ghc haskell

A simple round-robin data type

Limit number of IO actions started per second

Minimalistic actor library for Haskell

Simple and fast implementation of Future

Baisc, Erlang-like message passing for Haskell.

DISCONTINUED. set a maximum on the number of concurrent actions

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

Bundles shared calls to IO functions to perform them only once

Transactional I/O for duplex streams

utility for collapsing adjacent writes

A named lock that is created on demand.

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

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.

Build a Queue-Processing Worker Pool using Immortal

Haskell: Various concurrent combinators

Simple Haskel thread management in hierarchical manner

Thread delay and timeout functions with typed arguments

Fast concurrent queues much inspired by unagi-chan

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

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

Haskell channels with the forwarding primitive

Heartbeats for io-streams

A message passing concurrency extensible-effect

Practical actors for Haskell.

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

Monitor groups of threads with non-hierarchical lifetimes.

A trivial lock based on MVar