FunLoft is an experimental language for concurrent programming, designed with the following objectives:

• make concurrent programming simpler by providing a framework with a clear and sound semantics.
• provide a safe language, in which, for example, data-races are impossible.
• control the use of resources (CPU and memory); for example, memory leaks cannot occur in FunLoft programs, which always react in finite time.
• have an efficient implementation which can deal with large numbers of concurrent components.
• benefit from the real parallelism offered by multicore machines.

Cellular automata are typical examples of programs that can be easily encoded in FunLoft:

The cellular automaton shown in the image is an example of Game Of Life; it is made of concurrent cells run in a synchronised way; the number of cells can be large (here, 10K cells are present); the green and red cells can be run in real parallelism on a multicore machine; the program is proved to run in finite memory, without memory leaks and without data-races. To get an idea of what FunLoft programs look like, look at the code of the cellular automaton program. Examples of correct and incorrect programs are also available.

FunLoft is based on a programming model which is a variant of reactive programming and is closely related to FairThreads and LOFT. A list of general questions/answers about FunLoft is available here. FunLoft started to be developed with support from the ALIDECS project. It is now supported by the ANR project PARTOUT (ANR-08-EMER-O10).

The present language definition is subject to evolution to a large extent and is provided as is, with the hope that underlying ideas could be useful in a way or another.

A book entitled Safe Reactive Programming - The FunLoft Language is available from here. A first draft of the book is available from HAL.

The first paper presenting FunLoft is accessible from here. It appears in the Proceedings of MULTICOMP, First Workshop on Programmability Issues for Multi-Core Computers, Göteborg, 2008.

A formal description of FunLoft is available from (HAL).

The Synchronous-Pi-Calculus is a formal model of the reactive paradigm on which FunLoft is based. A research paper considers resource control for the Synchronous-Pi-calculus.

F. Dabrowski's PhD dissertation considers a framework almost identical to FunLoft and describes its semantics and several related aspects (for example, resource control) in detail. A research paper investigates the problem of data-races for a minimal kernel of the model we consider. It has been presented at TV06, Multithreading in Hardware and Software: Formal Approaches to Design and Verification, Seattle, 2006.

An example of colliding particles is proposed as a benchmark for multicore architectures. A brief note describing it is available.

Slides:

• Presentation of the global approach (april 2007)
• Presentation at SYNCHRON 2007 (november 2007)
• Presentation at MULTIPROG 2008 (january 2008)

The current version (v0.4) of the FunLoft compiler is available under the Gnu Public License. It runs on Linux and MacOS X.

More or less closely involved in the language definition, are the following persons:

• Roberto Amadio, for formal aspects of the model (S-pi-calculus).
• Frederic Boussinot, for reactive programming and implementation aspects.
• Frederic Dabrowski, for safety and resource control aspects.

Correspondence can be addressed to Frederic Boussinot.