transient: composing programs with multithreading, events and distributed computing

[ concurrency, control, library, mit ] [ Propose Tags ]

See Distributed primitives are in the transient-universe package. Web primitives are in the axiom package.

[Skip to Readme]


Manual Flags


Enable debugging outputs


Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info


Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


Versions [RSS],,,,,,, 0.1.1, 0.3, 0.4.0, 0.4.1, 0.4.2,, 0.4.4,, 0.5.1, 0.5.3, 0.5.4, 0.5.5, 0.5.6, 0.5.8, 0.5.9,,,,, 0.6.3,
Change log
Dependencies base (>=4.8.0 && <5), bytestring (>=0.10.6), containers (>=0.5.6), directory (>=1.2.2), mtl, random, stm, time (>=1.5), transformers (>=0.4.2) [details]
License MIT
Author Alberto G. Corona
Category Control, Concurrency
Home page
Bug tracker
Source repo head: git clone
Uploaded by AlbertoCorona at 2020-07-24T11:50:50Z
Reverse Dependencies 4 direct, 1 indirect [details]
Downloads 19211 total (87 in the last 30 days)
Rating 2.5 (votes: 3) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2020-07-24 [all 1 reports]

Readme for transient-

[back to package description]

Transient logo

Hackage Stackage LTS Stackage Nightly Build Status Gitter


NOTE: distributed computing and web primitives Are in transient-universe and axiom. Some examples at transient-examples

Some feedback on transient:

  1. Rahul Muttineni @rahulmutt nov. 09 2016 03:40 Lead developper of ETA (the JVM Haskell compiler)

    It's a bit mind bending in that it's like using a higher-level list monad, but it's very, very cool. For beginning Haskellers, what would be really useful is a visualisation of what happens when you do various distributed/parallel stuff. It's almost shocking how effortlessly you can run computations across threads/nodes.

    The cool part is the composability in the distributed setting. You can make higher-order monadic functions that allow you to compose & reuse a long chain of distributed transactions via wormhole and teleport. Another benefit is that the transaction becomes first class and you can see exactly what's going on in one place instead of distributing the logic across actors making the code equivalent to event callbacks, as you've stated.

What is Transient?

One of the dreams of software engineering is unrestricted composability.

This may be put in these terms:

let ap1 and ap2 two applications with arbitrary complexity, with all effects including multiple threads, asynchronous IO, indeterminism, events and perhaps, distributed computing.

Then the combinations:

 - ap1 <|> ap2          -- Alternative expression
 - ap1 >>= \x -> ap2    -- monadic sequence
 - ap1 <> ap2           -- monoidal expression
 - (,) <$> ap1 <*> ap2  -- Applicative expression

are possible if the types match, and generate new applications that are composable as well.

Transient does exactly that.

The operators <$> <*> and <> express concurrency, the operator <|> express parallelism and >>= for sequencing of threads, distributed processes or web widgets. So even in the presence of these effects and others, everything is composable.

For this purpose transient is an extensible effects monad with all major effects and primitives for parallelism, events, asynchronous IO, early termination, non-determinism logging and distributed computing. Since it is possible to extend it with more effects without adding monad transformers, the composability is assured.

Motivating example

This program, will stream "hello world" from all the nodes connected if you enter "fire" in the console

main= keep $ initNode $ inputNodes <|> distribStream

distribStream= do
      local $ option "fire" "fire"
      r <- clustered . local . choose $ repeat "hello world"
      localIO $ print r

Read the tutorial to know how to compile and invoke it.

This program will present a link in the browser and stream fibonnacci numbers to the browser when yo click it. (if you have Docker, you can run it straigh from the console; See this

main= keep . initNode $ webFib

webFib= onBrowser $ do
    local . render $  wlink () (h1 "hello fibonacci numbers")

    r <-  atRemote $ do
                r <- local . threads 1 . choose $ take 10 fibs
                localIO $ print r
                localIO $ threadDelay 1000000
                return r

    local . render . rawHtml $ (h2 r)
    fibs = 0 : 1 : zipWith (+) fibs (tail fibs) :: [Int]

This program combines both functionalities:

main= keep . initNode $ inputNodes <|> webFib <|> distribStream


The Wiki is more user oriented

My video sessions in not intended as tutorials or presentations, but show some of the latest features running.

The articles are more technical:

These articles contain executable examples (not now, since the site no longer support the execution of haskell snippets).


Once composability in the large is possible, there are a infinite quantity of ideas that may be realized. There are short term and long term goals. An status of development is regularly published in Gitter.

Among the most crazy ones is the possibility of extending this framework to other languages and make them interoperable. treating whole packaged applications as components, and docking them as lego pieces in a new layer of the Operating system where the shell allows such kind of type safe docking. this composable docker allows all kinds of composability, while the current docker platform is just a form of degraded monoid that do not compute.


Wanna contribute? Make sure that you've read our contributor guidelines. We'd like to hear from you and your ideas, get in touch with other contributors through:

Once you learn something interesting, you can contribute to the wiki

You can also donate to the lead developer in order to make possible the dedication of more time to fullfil the potential advantages of true software composability across the whole stack.