MUSCLE v1 installation

The recent bundle of MUSCLE can be downloaded from the Downloads section. The bundled package contains the source code, documentation and precompiled Java archives (jar). We maintain a list of clusters where MUSCLE is already deployed.

The offered version of MUSCLE in several places extends and improve the  package provided by Jan Hegewald. We can list here the following elements:

  • improved installation procedure (some dependencies are already included in the bundle),
  • added support for generation of OTF trace logs,
  • implemented Port Range traversing technique for cross-cluster execution.


The core functionality of the MUSCLE is written in Java. To be able to integrate native code with the MUSCLE, there is also a native part which is written in C++. Bootstrapping and platform independent configuration is done with a flexible setup mechanism written in Ruby.

In order to use the MUSCLE, you need a recent Java runtime, either  Oracle-Java] or [[|Open-JDK. Main Java third-party dependencies are already provided in the bundle and do not need to be independently installed.

For the command-line interface  Ruby is needed.

To compile and install MUSCLE, the  CMake package. For the C++ library,  Boost is needed.

Installation of dependencies on a Debian flavored Linux


sudo apt-get install build-essentials cmake ruby ruby-dev libboost-dev libgemplugin-ruby

to install all dependencies at once.

Installation of dependencies on Scientific Linux 5.6

Note: Some part of the presented installation procedure requires to be invoked by root.

  1. Check if a proper version of ruby is already installed in the system, otherwise install it:
    ruby --version
    -bash: ruby: command not found
    yum install ruby
    ruby --version
    ruby 1.8.5 (2006-08-25) [x86_64-linux]
  1. Ensure if you have a c++ compiler available on your system. If you have not, install this:
    yum install gcc-c++
  1. Check if cmake is available, otherwise install cmake:
    yum install cmake
    Note: you may need to add the reference to the repository with extra packages. To do this create the file 'epel.repo' in the /etc/yum.repos.d directory. The content of the file may look as follows:
    name=Extra Packages for Enterprise Linux 5 - $basearch 
  1. Check if recent Java SE Runtime Environment (JRE) or Java SE Development Kit (JDK) are present in your system. As the precompiled MUSCLE package is already included at build/muscle.jar you may not need to compile the Java sources and JRE should be sufficient. Hovewer, if you want to recompile the Java part of the MUSCLE (recommended), a recent Java compiler is also required.
    yum install jdk

Installation of dependencies on Mac OS X

Most dependencies are installed when installing Xcode. In  Xcode 4.3, the command-line tools are installed by opening Preferences -> Downloads and pressing Install at the item "Command-line tools". For Boost and CMake, download the packages on their website or use an installation manager like  HomeBrew or  MacPorts.

Remainder of the installation

If your ruby version is 1.8.x, then it is necessary to install json with the following command

sudo gem install json

When the dependencies are in place, you are ready to build and install MUSCLE. Download the muscle bundle from Downloads section, e.g.


Extract the download, e.g.

$ unzip

Change your working directory to the the MUSCLE directory:

$ cd muscle-1.1.1

Invoke MUSCLE build script with installation (we are installing muscle to the /opt/muscle directory which is default, type ./build.rb for more options):

$ ./build.rb install --prefix=/opt/muscle

See if MUSCLE is working correctly:

$ /opt/muscle/bin/muscle --version

Sample execution

There are some examples provided within the MUSCLE bundle. Example code for kernels can be found in the directories src/java/examples and src/cpp/examples. There are also prepared configurations for coupled examples CxA (MUSCLE simulations), which can be found in the src/cxa directory.

Hello World


At src/java/examples/simplejava/Sender we provide a minimalist kernel written in Java, which sends data (an array of double).


At src/java/examples/simplejava/ConsoleWriter we provide a simple kernel written in Java. It receives data (an array of double) and prints its content to the standard output.

CxA (coupling schema)

The configuration src/cxa/SimpleExample.cxa.rb configures a minimal CxA which couples the src/java/examples/simplejava/Sender and src/java/examples/simplejava/ConsoleWriter kernels.


To run the simulation defined in src/cxa/SimpleExample.cxa.rb use the following command:

/opt/muscle/bin/muscle --cxa_file src/cxa/SimpleExample.cxa.rb --main plumber w r --autoquit

Further reading

For more information how to use MUSCLE see doc/muscle_developers_guide.pdf included in the MUSCLE bundle.