In the wake of Michael's proposal, I think I should post a little
description of what Quasimodo is, since I think that a number of
people on both the lists this is sent to don't know enough about
it. Its purpose is not identical to Michael's idea, but the
similarities are important.
---------------------------------------------------------------------
Quasimodo is written in C++. It makes strong use of contemporary C++
techniques.

Quasimodo is a reimplementation of the Csound "engine". It uses the
same source code for the UG's as Csound (after running them through a
perl filter to fix a couple of minor details). Almost every Csound
opcode is available for Quasimodo, with the exception of those that
cannot be executed in real-time, though these will be ported
eventually. Even Sean Costello's recent additions (svfilter, hilbert,
resonz and resonr) are already part of Quasimodo (I ported them the
same day 3.55 was released).

Quasimodo contains plugin parsers for handling languages. It currently
has such parsers for the Csound orchestra and score languages, and
will soon feature other languages as well (e.g. SAOL and my own
contribution of a more C-like instrument language). The parsers are
automatically generated by Bison and flex from formal grammar
specifications of the languages, and thus can be easily altered and
extended.

UG's are handled as plugins, and are dynamically loaded if and only if
an instrument definition calls for them. You can create a new UG and
load it into a running version of Quasimodo.

Quasimodo also uses a plugin model for its user interface, and
currently comes with both a GTK+/Gtk-- based GUI and a very
non-functional command line interface.

Quasimodo supports real-time editing of instrument variables, and
real-time patching between different instruments. You can twist a knob
(real or virtual), and the value of a given variable in an instrument
will be altered as you move it. There is no latency other than
whatever audio buffering is in place. The patching system does most of
what the zak system does, but doesn't require instruments to know
whether or not they are patched together.

Quasimodo compiles Csound instruments into an internal abstract
expression tree of the kind used in other compilers, allowing
Quasimodo to potentially do optimization on instrument definitions.

Quasimodo supports real-time MIDI and other event input, and times
MIDI events separately from audio data, though the two are held in
tight synchrony. This separation allows Quasimodo to handle MIDI
correctly even when there is no audio output, and does not rely on a
run-time command line flag to do this. Quasimodo will soon support a
shared memory API allowing it to be controlled by other programs
directly.

The current GUI also supports full binding of any and all visual control
elements (knobs, sliders, buttons etc.) to MIDI controllers.

Quasimodo (will shortly) use XML for its instrument files (though we
call them "modules"). 

Quasimodo is multithreaded, and can take full advantage of dual CPU
platforms. A future version will take full advantage of platforms with
more than 2 processors as well.

Quasimodo supports storing function tables on disk for later use. When
used, no (explicit) data copying takes place (thanks to mmap(2)),
allowing enormous function tables to be handled efficiently.

Quasimodo uses mmap(2) for all handling of "in memory" sound files and
other data, avoiding data copying. Soundfiles and function tables are
reference counted, and will be freed when they are no longer needed.

Quasimodo uses a version of Bill Schottstaedt's sndlib for handling
soundfiles, allowing it to handle a large variety of sound file
formats.

Quasimodo is free, released under the GNU General Public License, and
is designed for operating systems that support the POSIX standard. It
currently runs on Linux and SGI IRIX. A Solaris port is underway (and
Be have expressed an interest in having it ported to BeOS). Yes, that
does mean that it does *not* run on Windows or MacOS systems. A port
to Windows would be possible; a port to the MacOS would be extremely
difficult, since the MacOS does not use preemptive scheduling.

Quasimodo is still under a great deal of development.

--p