Reuseware Composition Framework
Components, Modules, Aspects or something new?
Introduce new Composition Techniques into your Language of Choice with Reuseware!


Reuseware in action: Creating model fragments
Reuseware in action: Composing model fragments
Reuseware in action: Composing Xcerpt programs

Welcome to the Reuseware Composition Framework website. This site contains information about the development of a composition framework and its accompanying tools. The composition framework is targeting arbitrary software languages that are expressed in EMF Ecore (or EMOF) or in context-free grammars. These include languages relating to the Semantic Web and various modelling and domain-specific languages.

Reuseware is based on the idea of Invasive Software Composition (ISC) and has been under development since 2005. Since then, different versions of the tooling have emerged. For an overview of the different versions pleas consult the brief History on Reuseware.

Reuseware Poster: PDF


The purpose of this work is to provide composition technology and techniques to formal languages lacking such built-in mechanisms. The work is specifically aimed towards languages in the context of the Semantic Web, such as OWL, Xcerpt, XQuery, and modeling languages, such as UML, but is not limited to them.

Such techniques will allow for componentization and composition of artifacts written in these languages and will foster re-use in the Semantic Web and model-driven software development processes. From simple composition, we also look towards more advanced techniques such as view-based programming, aspects etc. The composition techniques used are based on Invasive Software Composition (ISC).

One of the core goals of the project is to create a robust and flexible framework where old, well-known, composition techniques can be implemented for arbitrary languages, as well as easily being able to implement and experiment with new interesting techniques!

Tool support

Reuseware runtime architecture

To support these ideas we are developing a toolset: Reuseware Composition Framework. The current implementation integrates into Eclipse is available for Download.

Tutorials, examples and screencasts demonstrate the usage of the tooling on different Applications.

Check out our Screencasts section for a quick start on the tooling.


Many of the languages used today in software engineering have poor built-in support for software composition. As is well-known, there are many benefits to be harvested from creating software based on components and this method is considered a vital part of large mature systems. Among other things, creating software from components allow for reuse of code. To address this problem one can re-design the individual languages such that they support composition based thinking and development. However, many languages are designed for some specific purpose and do not initially consider the component aspect. For example, the authors of an XML query language might not initially consider how to develop queries in a modular fashion using components. Rather, the design is focused on the querying aspects of the language, and rightly so. This does not mean, however, that component based development will not play a role in the authoring of XML queries once the query language is mature and used in complex systems. Thus, trying to realize and enable software composition on the level of individual languages is not ideal.

On the other hand, one can consider the possibility of addressing the problem on a language independent level, without tampering with the specifics of each individual language. This has the advantage that the same composition technique can be re-used for every language. More importantly, one can create a general tool framework for enabling component based development for a number of languages lacking such capabilities.


The core of the proposed idea is language independent: any language can be made to support composition and to foster re-use. The only assumption is the existence of the language's meta-model: a description of its constructs and their relations. Different meta-modeling languages can be considered. Currently, we have experience with EBNF, MOF and OWL. We are then able to extend this meta-model into one that also includes concepts about composition. We call the underlying language a core language and an extended meta-model a description of a reuse language. The reuse-language is closely related to the component model used for the composition.