What is KIARA?

KIARA Fiware Advanced Middleware is a Java based communication middleware for modern, efficient and secure applications. It is an implementation of the FIWARE Advanced Middleware Generic Enabler. The FIWARE platform provides a rather simple yet powerful set of APIs (Application Programming Interfaces) that ease the development of Smart Applications in multiple vertical sectors.

The FIWARE Catalogue contains a rich library of components (Generic Enablers) with reference implementations that allow developers to put into effect functionalities such as the connection to the Internet of Things or Big Data analysis, making programming much easier.

Main features:

  • High performance
  • Designed according to open standards: OMG IDL, CDR, etc.
  • Portable and Multi-platform: Java based library
  • Easy to use: See a Hello-World video tutorial here
  • Free and Open Source: KIARA is licensed under LGPL

KIARA is being developed as a joint project with our partners the Zurich University of Applied Sciences (ZHAW), the German Research Center for Artificial Intelligence (DFKI) and Saarland University/Center for IT Security, Privacy, and Accountability (CISPA).

Download distribution:

KIARA Advanced Middleware is not provided in a self-contained package. It has been designed by following the last Java coding standards, and therefore it's fully compatible with Maven and Gradle, meaning the developer does not need to manually install any libraries, making KIARA even easier to use.

In order to download and use KIARA, please follow the instructions in the Installation and Administration Guide (the link can be found in the Documentation section below):




KIARA: Hello World Video:


What does KIARA offer?

Implement transparent, fast, secure and standard conform communication between applications or services running under different machines and using different Operating Systems. It also provides the users with a friendly and extensible API.

In contrast to other GEs, the Advanced Middleware GE is not a standalone service running in the network, but a set of compile-time and run-time tools and a communication library to be integrated with the application. Thus, the requirements are rather minimal. In particular it requires no service running in the background.

This first release focuses on the basic features of RPC communication:

  • Easy to use and extensible Application Programmer Interface (API).
  • Synchronous and Asynchronous function calls.
  • Modern Interface Definition Language (IDL) → Based on Corba IDL
  • OMG Compliant
  • Extended primitive types.
  • IDL derived operation mode for RPC Client/Server implementation
  • By generating Stubs and Skeletons at compile time → RPC API
  • By using proxies to provide and call the functions at runtime → RPC Dynamic Types API

Later versions will include additional features like:

  • Additional communication patterns like publish/subscribe.
  • Advanced security features like field encryption and authentication.
  • Application derived and Mapped operation mode providing dynamic declaration of functions and data type mapping.

Open Specification:

KIARA is an implementation of the FIWARE Advanced Middleware Generic Enabler. More specifically, KIARA implements the following Open Specifications and APIs:

A quick example:

In the IDL derived approach, first the IDL definition has to be created:

service Calculator {
float32 add (float32 n1, float32 n2);
float32 subtract (float32 n1, float32 n2);

The developer has to implement the functions inside the class CalculatorServantImpl:

public static class CalculatorServantImpl extends CalculatorServant
public float add (/*in*/ float n1, /*in*/ float n2) {
return (float) n1 n2;

public float subtract (/*in*/ float n1, /*in*/ float n2) {
return (float) n1 - n2;

Now the server can be started:

// Create context, server and service
Context context = Kiara.createContext();
Server server = context.createServer();
Service service = context.createService();

// Create and register an instance of the CalculatorServant implementation.
CalculatorServant Calculator_impl = new CalculatorServantImpl();

// register the service on port 9090 using CDR serialization
server.addService(service, "tcp://", "cdr");

// run the server

The client can connect and call the remote functions via the proxy class:

// Create context
Context context = Kiara.createContext();

// setup the connection to the server
Connection connection = context.connect("tcp://");

// get the client Proxy implementation
CalculatorClient client = connection.getServiceProxy(CalculatorClient.class);

// Call the remote methods
float result = client.add(3, 5);


For any questions please contact This email address is being protected from spambots. You need JavaScript enabled to view it.