In traditional software engineering domains, Model-Driven Development (MDD) using UML or domain-specific languages (DSL) has been successfully established. However, although MDD is a particularly promising approach to avoid implementation errors due to miscommunication between heterogenous developer groups, i.e. 3D modellers and application programmers, only a few MDD approaches for 3D development have been proposed so far.

Moreover, 3D development is usually a highly iterative process. Round-trip engineering is a modern software development technology that aims to synchronize the often concurrently generated models and program source code in order to support the iterative development process. Round-trip engineering combines a forward phase, where code is automatically generated from an abstract model of the application, with a reverse phase, where manual code edits are merged back into the abstract model.

In the Roundtrip3D project, new methods supporting the model-driven, iterative development of 3D applications are investigated. In particular, we aim to extend SSIML, a MDD approach for 3D development to full round-trip engineering. Secondly, to address the interdisciplinary development process, where 3D modellers and programmers use their own tools, the manually developed code bases have to be synchronized in a non-simultaneous way. A third focus is on the (semi-) automatic adaptation of 3D software to multiple hardware and software platforms (e.g. handhelds, desktop PCs and even CAVE-like systems) via model-driven methods.

Figure 1: Model-driven and iterative development process
for 3D applications.

A small example

The example is a simulation of a robot in a factory. The 3D scene is composed of the following 3D objects: A factory hall (Figure 2(a)) that already contains accessories like boxes, a simplified model of an industrial robot (Figure 2(b)) that is explicitly made up of its single components and a panel with four control buttons (Figure 2(c)). The 3D designers’ task is to model the individual 3D objects and their composition in a single scene. Furthermore, the application shall provide an interactive part that allows the user to control the robot directly within the 3D scene, by pressing buttons on the panel using the mouse. This interaction and animation part has to be programmed in JavaScript.

SSIML editor
SSIML editor
Figure 2(b): Industrial robot
SSIML editor
Figure 2(a): Factory hall
Figure 2(c): Control pult

To model so called 3D scene graphs at a high level of abstraction and interrelationships between application code and 3D code, we use a graphical Domain Specific Language called SSIML (Scene Structure and Integration Modeling Language).
Figure 3 depicts a SSIML model for the example, that serves as specification for both the 3D designers’ and JavaScript programmers’ tasks. (The model has been created in our GMF-based editor.)

SSIML editor
Figure 3: A SSIML model to specify the 3D application, with scene graph elements mainly located to the left and interrelationship elements, such as the application component RobotControl, located on the right side.

Round-Trip Engineering (RTE) for 3D Applications

Developing 3D applications involves multiple target languages (TLs), e.g. X3D to declare the 3D scene and JavaScript for further application logic. Our approach to RTE for 3D applications uses a multi-tiered approach, to split complex forward and reverse transformations into sequences of more manageable ones.

Additionally, we use an intermediate model (IM) that provides a common representation for all participating languages (i.e. SSIML, JavaScript, X3D and X3DOM), in order to avoid synchronization issues that result from heterogeneous target languages that have to be merged during the round-trip to preserve consistency of the overall application.

A persistent IM further allows for a non-simultaneous synchronization of the various models and code artifacts which is mandated by the concurrent development process of 3D applications.

Figure 4 depicts our overall round-trip process. SSIML models are first converted into their intermediate representation with Java and EMF. Combining a rule-based transformation language (ETL) with an additional mapping model (for SSIML elements and target language constructs) allows for managable transformations between IMs and the respective Abstract Syntax Trees (ASTs). Code serializers and parsers are generated using Xtext.

Figure 4: The overall round-trip process with involved models and transformations. Derived intermediate models are sequentially merged into the persistent IM.

After programmers implemented the application logic and 3D designers composed the scene concurrently, the code bases are parsed and the ASTs are transformed into their intermediate representation. After an interactive merge process with conflict handling, a SSIML model is derived from the persistent IM. Software engineers can use the SSIML model to comprehend modifications and to re-design the application.

During the next forward iteration, 3D code and application code is completely re-generated from the IM. Inconsistencies which may result from the concurrent development, e.g. different names of scene objects in JavaScript and X3D code, have been eliminated through the synchronization at the intermediate stage.

We created interactive examples (for the web) using the described round-trip development process with several iterations:

The car configurator application has firstly been developed for the web. Afterwards, it has been ported to other platforms, i.e. a CAVE and a prototypical version for tablet PCs with Augmented Reality.

web application

CAVE application

tablet application
Figure 5: The car configurator application in a Web version (a), a CAVE version (b) and a tablet version for Augmented Reality (c)

Detailed information about the round-trip development process can be found in the publications section.


  • Prof. B. Jung
  • M. Lenk
  • Dr. A. Vitzthum, University of Cooperative Education (BA), Dresden, Saxony
  • C. Schlegel
  • D. Arnold
  • H. Müller



B. Jung, M. Lenk, A. Vitzthum. Structured Development of 3D Applications: Round-Trip Engineering in Interdisciplinary Teams. Computer Science - Research and Development (CSRD), Online First, Springer, 2014. DOI 10.1007/s00450-014-0258-8


B. Jung, M. Lenk, A. Vitzthum. Model-Driven Multi-Platform Development of 3D Applications with Round-Trip Engineering. Software Engineering 2013. (37% acceptance rate)


M. Lenk, C. Schlegel, A. Vitzthum & B. Jung. Round-trip Engineering for 3D Applications: Models and Transformations. Fakultät für Mathematik und Informatik, Preprint 2012-06 (PDF)

Matthias Lenk, Arnd Vitzthum, and Bernhard Jung. 2012. Model-driven iterative development of 3D web-applications using SSIML, X3D and JavaScript. In Proceedings of the 17th International Conference on 3D Web Technology (Web3D '12). ACM, New York, NY, USA, 161-169. (28% acceptance rate).

M. Lenk, A. Vitzthum & B. Jung. Non-Simultaneous Round-Trip Engineering for 3D Applications. SERP'12 - 11th International Conference on Software Engineering Research and Practice. (PDF)


A. Vitzthum & B. Jung. Model Driven Iterative VR and AR Development. IEEE VR 2010 Workshop on Software Engineering and Architectures for Realtime Interactive Systems (SEARIS). 2010.

T. Strobl, M. Minas, A. Pleuss, A. Vitzthum. From the Behavior Model of an Animated Visual Language to its Editing Environment Based on Graph Transformation. Electronic Communications of the EASST. Vol 32: Graph-based Tools. 2010.

Funded by: