Haskell Concurrency

Run IO operations asynchronously and wait for their results

Beautiful Streaming, Concurrent and Reactive Composition

Parallel scheduler, LVar data structures, and infrastructure to build more.

Run MonadConc operations asynchronously and wait for their results.

Chase & Lev work-stealing lock-free double-ended queues (deques).

Fast concurrent queues with a Chan-like API, and more

Model-view-controller

Cached and parallel data fetching.

Introduces conduits to channels, and promotes using conduits concurrently.

Concurrency for the pipes ecosystem

Running worker processes under system resource restrictions

OTP-like supervision trees in Haskell

A command line type checker for CSPM files.

Containers for STM

Concurrent PostgreSQL data consumers

Fork threads and wait for their result

Distributed, stateful, homogeneous microservice framework.

Extra queue utilities for STM

Run lifted IO operations asynchronously and wait for their results

Extra concurrency primitives

Concurrent networked stream transducers

Simple, IO-based library for Erlang-style thread supervision

Sirkel, a Chord DHT

A fast concurrent unique identifier supply with a pure API

Lazy demand-driven promises

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

A principal solution to ghost threads and silent exceptions

A typeclass for mutable references that have an atomic modify operation.

Non-blocking concurrent map

Simple package that implements timers.

(deprecated in favor of 'threads') Simple thread management

Unbounded thread delays and timeouts

Concurrent and combinable updates

Loop over an action but throttle it to a certain rate

Rate limiter using lazy bucket algorithm

Provides access to the dynamic pointer tagging bits used by GHC.

Implementation of bounded channels.

Much safer replacement for QSemN, QSem, and SampleVar

Fully concurrent unique identifiers

Go-style channels

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

A library for more structured concurrent programming, based on the Actor Model

Unagi Chan IO-Streams

A concurrent utility inspired by Ticker in golang

Generalized sleep and timeout functions

Updatable timeouts as a Monad transformer

A monadic interface for async

Contention-free STM hash map

Kick Channels

Tiny library for concurrent computations

A fast, cache-efficient, concurrent bloom filter

Streaming to and from subprocesses using Pipes

Concurrent actions that may fail with a value.

Chunked Communication Queues

A named lock that is created on demand.

Runs a time-limited computation alowing it to return intermediate results.

NCurses interface to view multiple ByteString streams in parallel.

Limit number of IO actions started per second

Extra Utilities for the Async Library

A simple round-robin data type

Lightweight Erlang-style actors for Haskell.

Throttler between arbitrary IO producer and consumer functions

Simple package that allows for long thread suspensions.

Basic Erlang-like process support for Haskell

Practical actors for Haskell.

Bundles shared calls to IO functions to perform them only once

Transactional I/O for duplex streams

Synchronize actions to a time pulse

Provides API for timer based execution of IO actions

Baisc, Erlang-like message passing supporting sockets.

Concurrent channels with a forwarding primitive

Simple thread barriers

Fast concurrent queues much inspired by unagi-chan

utility for collapsing adjacent writes

Multiple-read / single-write locks

Useful concurrent combinators

Thread delay and timeout functions with typed arguments

Simple Haskel thread management in hierarchical manner

Heartbeats for io-streams

STM's TChan split into sending and receiving halves.

Extra STM functions

Minimalistic actor library

A trivial lock based on MVar.

mecha are the most complex composite machines known to humanity, lets build them well!

GraphHammer Haskell graph analyses framework inspired by STINGER.