ANN: Kamaelia 0.2.0 has been released!

Michael Sparks michaels at
Mon Aug 1 19:48:35 CEST 2005

Kamaelia 0.2.0 has been released!

What is it?
Kamaelia is a collection of Axon components designed for network
protocol experimentation in a single threaded, select based environment.
Axon components are python generators are augmented by inbox and outbox
queues (lists) for communication in a communicating sequential processes
(CSP) like fashion.

The architecture is specifically designed to try and simplify the
process of designing and experimenting with new network protocols in
real environments. More background on the motivations behind Kamaelia
can be found here:

The focus of this release adds in support for introspection, pygame based
interfaces, 4 new examples using these, visualisation tools, as well as
syntactic sugar to make building Kamaelia systems simpler. (Specifically
Graphline and pipeline systems. This build upon the existing base allowing
TCP and Multicast based client/server systems.

Other additions and changes include updated examples, variety of bugfixes
in existing components (some pre-emptively discovered by introspection), and
a variety of utility components. It is now also possible to write components
using threading as the concurrency model rather than generators - allowing
integration with thread/blocking only based systems.

The system is known to work under Linux, Mac OS X, Windows and a subset
has been tested on Series 60 mobiles.

General feedback is welcome either directly, mailing lists or via the
project weblog which is here:

What's new in version 0.2.0 ?

Lots! Full release notes can be found here:

Editted highlights...

Debian Packages! Many thanks are due to Gintautas Miliauskas, Programmers
of Vilnius, for assistance in building Debian packages. (The current
packages are based on his, and any errors are likely to be mine, not
his) These have been tested successfully on Ubuntu 5.04.

4 new examples have been added showing of various new subsystem:
   * Example 5 : This creates a simple streaming system, and looks inside
     to see what components are running/active, and passes the resulting
     information an Axon Visualiser.

   * Example 6 : This is a simple/generic topology visualisation server.
     Accepts the following commands over the network
        ADD NODE id label auto -
        ADD LINK id id
        DEL NODE id
        DEL ALL
     As this stands this is pretty useful, but that's pretty much everything
     it does like this.

   * Example 7 : This shows how the visualisation subsystem can be extended
     to work in different ways. What this does by default when run is
     randomly create new nodes and new linkages quite quickly, allowing
     you to see how the system works.

   * Example 8 : Sample slideshow/presentation tool. Unlike traditional
     slideshow/presentation tools, you can modify this to run arbitrary
     components. An example of how this can work is provided - allowing
     stepping through some graph visualisations along with the presentation.

A Tools directoy has been added with the following tools:
   * Axon Shell. (Requires IPython) Implements a simple command line shell
     which allows experimentation with Axon systems - the shell runs a
     scheduler as a background thread. For a tutorial of use, see:
   * Axon Visualiser. Implements a simple tool for looking inside (quite
     literally) running Axon/Kamaelia systems. This allows a very different
     style of debugging and can be extremely useful. Tutorial on its way!

Graphlines and Pipelines

  These are probably the most useful additions to Kamaelia since 0.1.2.
  They are essentially syntactic sugar for building and working with
  systems of components, but make building interesting systems rapidly
  out of pre-existing components fun and easy. The pipelines follow the
  same sort of model as the Unix pipeline. Graphlines are something new,
  and like pipelines and all linkages may take any data along them.

  Please take a look at the release notes for a graphline example.

  A couple of simple pipelines looks like this:

      ReadFileAdaptor(file_to_stream, readmode="bitrate", bitrate=400000,
      blockise(), # Ensure chunks small enough for multicasting!
      Multicast_transceiver("", 0, "", 1600),
      Multicast_transceiver("", 1600, "", 0),

A selection of other subsystems have been added - targeted at visualisation
of Kamaelia (and other graph structured) systems using pygame. The layout
mechanism is a simple physics engine. 

Key packages of note added: Kamaelia.UI, Kamaelia.UI.Pygame,
Kamaelia.Visualisation.Axon, Kamaelia.Visualisation.PhysicsGraph

    * Python 2.3 or higher recommended, though please do report any bugs
      with 2.2.
    * Axon (1.1.1 recommended)
    * vorbissimple (if you want to use the vorbis decode component/examples)

(Both Axon and vorbissimple are separate parts of the Kamaelia project,
and available at the same download location - see below)

Kamaelia has been used successfully under both Linux, Windows and Mac OS
X (panther). A subset of Kamaelia has been successfully tested on Series 60
mobiles when used with the Axon SERIES 60 branch.

Where can I get it?
Web pages are here: (includes info on mailing lists)

ViewCVS access is available here:


Kamaelia is released under the Mozilla tri-license scheme
(MPL1.1/GPL2.0/LGPL2.1). See

Best Regards, 

Michael.Sparks at,
British Broadcasting Corporation, Research and Development
Kingswood Warren, Surrey KT20 6NP

This message (and any attachments) may contain personal views
which are not the views of the BBC unless specifically stated.

More information about the Python-announce-list mailing list