[LAD] FAUST 0.9.10

[Orlarey Yann]

                            ================
                            | FAUST 0.9.10 |
                            ================

GRAME - Centre National de Creation Musicale - is happy to announce
the release of FAUST 0.9.10. This version introduces several new
possibilities. It is the first official release to offer full
parallelization of the C++ code to exploit multicore architectures,
as well as automatic generation of mathematical documentation.


-------------
About FAUST :
-------------

FAUST (Functional Audio Stream) is a functional programming
language specifically designed for real-time signal processing and
synthesis. A distinctive characteristic of FAUST is to be fully
compiled. The FAUST compiler translates DSP specifications into
very efficient C++ code that works at sample level. It targets
high-performance signal processing applications, libraries and
audio plug-ins for a variety of audio platforms and standards. A
same FAUST specification can be used to easily generate native
JACK or ALSA applications, as well as CSOUND, LADSPA, MAX/MSP, PD,
Q, SC and VST plugins.  

The Faust distribution can be downloaded at:
http://sourceforge.net/projects/faudiostream

Two mailing lists are available:
https://lists.sourceforge.net/lists/listinfo/faudiostream-devel
https://lists.sourceforge.net/lists/listinfo/faudiostream-users

In order to test FAUST without installing it, please refer to the
Online Faust Compiler:
http://faust.grame.fr


------------
What's new :
------------

A) C++ Code Generation
------------------

The Faust compiler translates Faust programs in C++. Several new
options have been added to control how the C++ code is generated,
in particular :

- control of the floating point precision : single (default),
  double, quad

- code re-organization in simple loops to facilitate automatic
vectorization

- automatic parallelization based on OpenMP

- automatic parallelization based on a specific "Work-Stealing"
algorithm


B) Mathematical Documentation
-----------------------------

Using formal methods the Faust compiler can produce automatically a
complete mathematical documentation of a Faust program. This
mathematical documentation is generated in Latex. It includes
equations, block-diagrams and listings. The documentation can be
customized by the user via <mdoc>...</mdoc> tags inserted in Faust
programs.

This documentation can be used to :

- preserve on the long term a Faust program in a purely
mathematical form, independently from Faust or any other
programming language

- bring some help to understand and debug a FAUST program by giving
the equations of each output signals according to the input signals
and the user interface parameters.


C) Language Extensions
----------------------

- Sequential composition operator (A:B) has been restricted to
expressions so that outputs(A) = inputs(B). This restriction has
several advantages. It improves error detection, makes the code
easier to understand and provides nicer and simpler formal semantic
( A:B is B o A)

- User interface labels can now contain metadata. For example the
label "volume[unit:dB][tooltip:control the output volume of the
reverb]" contains two metadata, a unit definition and a tooltip
message than can be exploited by an architecture file to fine tune
the user interface.

- User interface labels can contain absolute and relative pathnames
to better control the hierarchical structure of the user interface.
For example the label "../volume" points to place the widget one
group higher in the hierarchy.


D) New Audio Architectures
--------------------------

Several new audio architectures have been included, in particular
Action Script, CoreAudio, CSOUND, Chuck, Pure, SND-RT, for a total
of about 20 different plateforms now supported :

- Action Script

- Alsa

- ChucK

- CoreAudio

- CSOUND

- Jack

- LADSPA

- Matlab

- MaxMSP

- Octave

- OSS

- PortAudio

- Pure

- PureData

- Q

- Sndfile

- Snd-RT

- SuperCollider

- SynthFile

- VST

- VSTi (mono)


---------------
Acknowledgments
---------------

Many persons have been contributing to the FAUST project by
providing code for the compiler, architecture files, libraries,
examples, documentation, scripts, bug reports, ideas, etc.

I would like to thank them and especially: Fons Adriaensen, Tiziano
Bole, Thomas Charbonnel, Damien Cramet, Etienne Gaudrin, Albert
Graef, Stefan Kersten, Victor Lazzarini, Matthieu Leberre, Mathieu
Leroi, Kjetil Matheussen, Remy Muller, Nicolas Scaringella, Stephen
Sinclair, Travis Skare, Julius Smith, as well as my colleagues at
GRAME, in particular : Dominique Fober, Stephane Letz and Karim
Barkati, and from the ASTREE project : Jerome Barthelemy (IRCAM),
Alain Bonardi (IRCAM), Raffaele Ciavarella (IRCAM), Pierre Jouvelot
(Ecole des Mines/ParisTech), Laurent Pottier (U. Saint-Etienne)

Yann Orlarey
GRAME