Skip to main content



The Franca project is a proposed open source project under the Modeling Top-level Project.

This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process) and is written to declare its intent and scope. We solicit additional participation and input from the Eclipse community. Please send all feedback to the Eclipse Proposals Forum.


Interfaces are important artifacts in any kind of software architecture. They represent the contract between components, subsystems or systems and also between organizational units, like teams, departments, or companies. Therefore, in many development environments interfaces are modeled as first-class entities using an Interface Definition Language (short: IDL). However, for building large-scale platforms or systems, existing IDLs have at least two shortcomings:

  1. For integration of software systems which are contributed from various sources, it is necessary to map interfaces defined in one IDL to a software model using another IDL. E.g., in the international GENIVI consortium a platform for Automotive/Infotainment systems is being developed by integrating software components provided by various open-source projects, companies and institutions as GENIVI itself. The interfaces of these building blocks are either not modeled at all (e.g., plain C or C++ headers) or formally modeled in one of several methodologies, among them UML, D-Bus Introspection XML, annotated Java APIs. The integration of all contributions on model level can only be done by establishing mappings between all of these IDLs.
  2. Another common shortcoming in most existing IDL approaches is the lack of formality in modeling the dynamics of interfaces. Most IDLs provide means to model static aspects of the interface (e.g., data types, signals, methods, properties) as opposed to dynamic aspects (e.g., allowed sequences of events at the interface), which are most often regarded as optional add-on to the static interface definition.
    However, many severe bugs in complex software systems are caused by mismatches of the dynamic aspects of interfaces. These bugs will occur especially in late project phases (during system integration or even after customer delivery), are hard to identify and expensive to fix. Thus, it is necessary that the dynamic aspects should be part of the original interface definition, allowing extensive formal validation of the interface's implementations and usage. This can be done by static analysis or at runtime.

In order to address both issues, GENIVI started the Franca project, which can serve as a hub for IDL transformations and allows the specification of dynamic behavior as an integral part of each modeled interface. Part of Franca is a technology- and platform-neutral IDL. Franca has been initially contributed by Harman and has been published on EclipseLabs in March 2012 (under Eclipse Public License 1.0).


The Franca project provides a technology- and platform-neutral IDL including an easy-to-use editor based on the Eclipse IDE. The project also provides:

  • support for model-level system integration based on transformations from one IDL to another using Franca IDL as a central hub
  • a means to specify for each interface which interactions are allowed (Franca contracts)
  • tools supporting validation of implementations against Franca contracts
  • implementations of downstream code (and documentation) generators
  • for the addition of platform-specific deployment information to interface definitions
  • tools for supporting interface designers, e.g. a rapid prototyping tool which automatically generates an executable model out of a single interface definition


Franca is a framework for definition and transformation of software interfaces. It is used for integrating software components from different suppliers, which are built based on various runtime frameworks, platforms and IPC (Inter-Process Communication) mechanisms.

The diagram above shows the five aspects of the Franca framework.

  • IDL and feature-rich editor. The core of it is Franca IDL (Interface Definition Language), which is a textual language for specification of APIs.

  • Transformations and generation. Franca offers a framework for building transformations from/to other IDLs and model-based interface descriptions (e.g., D-Bus, UML, AUTOSAR, WebIDL) It also supports code generation with some open-source code generators already available. Support for the D-Bus Introspection format is available as installable feature of Franca.
    The diagram below shows a typical set-up of transformations (yellow) and generators (blue) built with Franca.

  • Specification of dynamic behavior. With Franca, the dynamic behavior of client/server interactions can be specified using protocol state machines. Tools are available to use these specifications for validating implementations, e.g., checking runtime traces against the expected order of events on the interface.
    A graphical viewer for protocol state machines is part of Franca. The following diagram shows an example screenshot.

  • Flexible deployment models. In specific application domains, it may be necessary to extend interface specifications by platform- or target-specific information. This is supported by Franca's deployment models, which allow these kind of extensions in a type-safe way.

  • Rapid interface prototyping. An executable test environment for an interface definition can be generated instantly, allowing users to see the interface in action. This is accomplished by generating eTrice models from Franca interfaces and generating executable Java code from these models. The generated test environment consists of a client component (acting as dynamic test case executor) and a server component (acting as an intelligent mock object).

Based on these features, there is a rich set of possible use-cases. Here are some examples:
  • Build your own component model based on EMF and use Franca for the IDL part.
  • Generate UML models from Franca interfaces and use those as part of a more detailed UML model of your system.
  • Generate standardized C++ bindings using GENIVI CommonAPI.
  • Convert Franca interfaces to D-Bus and use the tool-chain as already established on Linux desktops.
  • Use JavaScript-generator (part of Franca delivery) to generate JS-code which can be used to build HTML5-applications based on WebSockets.
  • Use Franca to create executable eTrice models and use them as a starting point for eTrice projects.
  • Check the interaction of runtime components on-the-fly based on their interface's dynamic behavior specification.

Current applications of Franca

Franca is an open-source project since March 2012. Thus, it is impossible to provide a complete list of applications. However, we will list some examples in order to show a part of the Franca community:
  • Franca is being used as an IDL and integration tool by the GENIVI consortium.
  • The CommonAPI C++ project uses Franca models as a starting point for all code generators.
  • The joynr web-based communication framework uses Franca as an IDL and as a basis for its Java and C++ code generators. The open-source joynr framework supports the interaction of applications which are deployed on consumer devices, vehicles, or backend infrastructure.
  • The Yamaica project is an Eclipse IDE extension providing a convenient UI for working with Franca models.
  • Several companies (including also non-Automotive) are using or evaluating Franca as an IDL for their internal software platform.

Why Eclipse?

Benefits Franca brings for the Eclipse community

Franca is already quite well-known and used across the Automotive/Infotainment domain. Therefore, it will provide additional value to the toolset Eclipse has to offer for the Automotive domain. It will especially attract companies to the Eclipse ecosystem which develop Infotainment solutions, just because of Franca's impact in that domain. This is valid not only for Eclipse as a community, but as well for the Automotive IWG at Eclipse.

Additionally, Franca might bring additional value to selected Eclipse projects by enabling some new inter-project functionality. E.g., there is already a feature to create eTrice models from Franca models. Also for projects tackling other application domains, Franca could be a valuable addition: E.g., Franca could serve as a bridge between Automotive applications and the growing M2M ecosystem, motivated by innovative Car2X use cases.

Benefits Franca gets by being hosted on Eclipse

Franca is based on several Eclipse-based technologies, among them EMF, Xtext and Xtend. Moreover, it optionally provides connections to other Eclipse projects (e.g., eTrice). Thus, by moving Franca into the Eclipse space, infrastructure topics can be coupled more tightly. For example, Franca releases can be aligned with the overall Eclipse release roadmap.

Moreover, the threshold for initial contributions established by the Eclipse foundation will help to increase the confidence companies will put into Franca. This includes the I.P. check, committer requirements and also the required continuity for release trains. This will improve the proliferation of the Franca concepts.

Finally, the visibility of Franca will be increased by being part of the Eclipse community. This will help attracting users, committers and other projects to connect with the Franca network.

Relationship with other Eclipse Projects

  • Franca's meta-models are based on EMF.
  • Both the Franca IDL and the deployment DSL have been created using Xtext.
  • For model-to-model transformations and code generation from Franca models, Xtend is being used.
  • Transformations are provided as part of Franca to generate executable models for eTrice.

Initial Contribution

The initial contribution consists of sources and artifacts found in the current Franca repository at Franca project. Copyright for the source files is partly held by Harman International, partly by itemis AG.

Franca uses the following third-party dependencies (aside from the Eclipse platform):

Legal Issues

All contributions will be distributed under the Eclipse Public License. The current code planned for initial distribution published at EclipseLabs (see Franca project) is distributed under the Eclipse Public License as well.


The following individuals are proposed as initial committers to the project:

Dr. Klaus Birken, itemis AG (project lead)
Klaus is initiator, maintainer and lead of the current pre-Eclipse Franca project. He has lead the initial contribution to EclipseLabs. Klaus is working in the GENIVI consortium since 2011 and is leading its Common IDL topic, which provided the requirements for the initial development of Franca.
Tamas Szabo, itemis AG
Tamas has provided significant contributions to the existing Franca code base. Tamas is also a committer of the Eclipse project EMF-IncQuery.
Steffen Weik, itemis AG
Steffen has provided significant contributions to the existing Franca code base, esp. regarding contract definition and trace-/testcase generation.

We welcome additional committers and contributions.


The following Architecture Council members will mentor this project:

  • Ed Merks
  • Eike Stepper

Interested Parties

The following individuals, organisations, companies and projects have expressed interest in this project:

Project Scheduling

  • December 2013: code submission and IP review
  • January 2014: first builds on the Eclipse infrastructure

Changes to this Document

Date Change
05-Nov-2013 Document created

Back to the top