This document describes Lucid Synchrone, a dedicated to the implementation of reactive
systems. Lucid Synchrone 1 is an
ML-extension of the synchronous data-flow language
The main features of the language are the following:
The language has a data-flow flavor à la
Lustre and the syntax is largely reminiscent to
the one of Objective Caml . It manages infinite sequences
or streams as primitive values. These streams are used for
representing input and output signals of a reactive system.
- The language provides some classical features of ML languages
such as higher-order (a function can be parameterized by a function or return
a function) or type inference.
- The language is build on the notion of clocks as a way to
specify different execution rates in a program. In Lucid Synchrone, clocks are
types and are computed automatically.
- Two program analysis are also provided. A causality analysis
rejects programs which cannot be statically scheduled and an
initialization analysis rejects programs whose behavior depends on
- The language allows for the definition of data-types: product types,
record types and sum types. Structured values can be accessed through
a pattern matching construction.
- Programs are compiled into Objective Caml. When required (through a
compilation flag), the compiler ensures that the resulting program is
“real-time”, i.e., it uses bounded memory and has a bounded response
time for all possible program inputs.
- A module system is provided for importing values from the host
language Objective Caml or from other synchronous modules.
3 is a major revision and offers
features with respect to versions
The language allows to combine data-flow equations with complex
state machines with various forms
- Activation conditions are done through a pattern matching mechanism.
- Besides the regular delay primitive
a new delay primitive called
last has been added in order to
make the communication between shared variables
in control structures (activation conditions or automata) easier.
- The language provides a way to define static values (i.e., infinite
constant sequences). These static values may be arbitrarily complex
but the compiler guaranty that they can be computed once for all, at
instantiation time, before the first reaction starts.
- It is possible to define valued signals. Signals are stream
values paired with a presence information (called enable in
circuit terminology). The value of signal can be accessed through a
pattern matching construct.
- The language supports streams of functions as a way to describe
- Sequential functions (as opposed to combinatorial function
to keep circuit terminology) must now be explicitly declared with the
keyword node. Otherwise, they are considered to be combinatorial.
- Internally, the compiler has been completely rewritten. We abandoned
the compilation method introduced in version
2.0 and came back
to the (co-iteration based) compilation method introduced in version
The current implementation is written in Objective Caml. The use of the
language needs the installation of Objective Caml.
The language is experimental and evolves continuously. Please send
comments or bug to Marc.Pouzet@lri.fr.
This software includes the Objective Caml run-time system, which is
copyrighted INRIA, 2006.