The JoCaml system is an experimental extension of the Objective-Caml language with the distributed join-calculus programming model. This model includes high-level communication and synchronising channels,mobile agents, failure detection and automatic memory management. JoCaml enables programmers to rapidly develop distributed large-scale applications, using both Objective-Caml ease of programmation and extended libraries, and the join-calculus distributed and concurrent features.

Mentioned on LtU before, but never in a separate story.

Could become Erlang-killer, if were not stopped for some reason.

Definitely worth trying, if only for ideas on how to bring powerful concurrency/distribution to a mature language.

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.


Funnel is a language that seems to only have been passingly mentioned as a language that compiles to Java bytecode. It looks like it would be an interesting thing to play around with. It doesn't look like it's aiming at a (completely) practical language* and at any rate, it appears development stopped a couple years back, but it still seems interesting.

*It does allow access to the Java API though.

I think it morphed into Scala

As far as I can tell, Scala sorta grew out of funnel, though scala is focused more on web services and less on the "functional nets" notion.

Other implemetations

C#/Java join calculus implementations may have caused JoCaml development to stop:

Small world

Funny, I started to read this paper half an hour ago... The world of join calculus must be small then...

Also worth mention is Inheritance in the Join Calculus (extended abstract on 13 pages).


When I heard about C# join-calculus implementation about half a year ago (Java's implementation actually pre-dates C#'s), I hoped that it would cause some interest among practitioners thanks to the implementation simplicity which does not require much knowledge of the underlying theory.

Apparently, I've been wrong. The best Java 5 can offer today is semaphores, various locks, thread-safe queues and such. These synchronization primitives are called for some unknown reason 'high-level threading mechanism' in one on-line Java publication.

Various Hoare's CSP Java libraries have suffered the same fate -- lack of interest in the development communities. I do know, however, about one successfull commercial project that used a Java CSP library quite efficiently.


It's not because of C#...

Unfortunately, JoCaml development stopped for a bunch of reasons. One of them was that it was a fork of Ocaml 1.07, and there would be quite some work to have a version that follows Ocaml development. Another reason is that the main developer for JoCaml was a PhD student who is now a researcher in another team.

Nevertheless, the main ideas behind JoCaml are still alive. The Join Calculus has been followed by many calculi, and some implementation ideas of JoCaml are slowly making their way into Ocaml.

If you read French, you can find a lot of information about JoCaml in Fabrice Le Fessant's PhD thesis.

There are also some summer school notes that can be of interest (Disclaimer: I'm an author of this last one).

JoCaml is dead- try Acute

JoCaml development is basically stopped at this point- the current incarnation of the Join Calculus on Ocaml is Acute:

Source Release!

It's perhaps worth noting that although Acute has been mentioned on LtU before, at the time there were only papers. Now there's a source release for people to play with!

Concurrency primitives in Acute

I've taken a cursory look at Acute's concurrency implementation. According to the manual (paragraph 9.10), the primitives are just: 'thread', 'mutex' and 'condition variable'. For the argument sake, let's forget about the distributed concurrency tool 'thunkify' and pretend we are concerned only with local concurrency.

In my opinion, this is no different from what, say, the current Java has to offer and is a huge step backwards in comparison to JoCaml with its join calculus. Acute's mecahnism is low level and, as such, prone to the usual host of problems. Even 20-year-old Hoare's CSP would have been a better idea.

I apologize if I missed something important in Acutes's concurrency mechanism -- I did not see join calculus primitives in Acute.


This is a fair observation, because Acute isn't trying to impose a particular calculus, and so has chosen to provide a rich-but-risky set of primitives. Out of those primitives, though, one can construct a module offering the semantics of any number of calculi, and in fact one of the Acute examples is indeed the Npi module, which offers semantics inspired by the Nomadic Pict language, which in turn is based on a variant of the Pi Calculus.

JoCaml is alive again, and kicking goals

JoCaml has been revived, on the same site as previously ( and is performing very well in the Tim Bray Wide Finder project.

Grand Unified OCaml Theory

I wonder if it would be possible to put together, somehow, the various dialects of OCaml that people have created? I'd be particularly interested in a MetaJoCaml. :-)

Still, the resurrection of JoCaml is indeed exciting. Concurrency and distribution are too important to leave to Erlang and Oz!