Zaluum graphical programming

Open source visual language for real-time data processing.

Download Zaluum Alpha » Zaluum on GitHub »

  • Visual programming

  • Eclipse based, Java Compatible

  • Integrated GUI Editor

NOTE Zaluum is currently in alpha stage. It's not feature complete. We need your ideas Comment »


Visually expressive

The expressive power of a drawing, a diagram or a sketch is undeniable. How many times have you used a visual representation to explain your thoughts, solutions or needs? We believe that you can use the geometrical, spatial abilities of the human brain to program computers in an effective and intuitive way. Of course, written language plays an essential role in the communication between humans and between human and machine.

Zaluum recognizes and embraces both facts: the power of visual diagrams and value of textual programming and blends them in an environment where you can seamlessly choose how to express yourself. The best of both worlds.

Engage non-programmers

Users that don't have a strong background in computer science are often intimidated by the syntax and quirks of textural programming languages. A visual programming language allows to lower the entry barrier for this type of user. With Zaluum, both programmers and non-programmers can collaborate mixing their programming skills. Each individual can concentrate in the problem using the tools she is most comfortable with.

Mix textual and graphical programming

Zaluum recognizes and embraces the power of textual programming. Some algorithms are much better expressed in a textual form, some others are far better drawn. Zaluum does not dictate what style you should use: it encourages to mix in the same project both visual and textual source code. Write what it makes sense to be written, draw what you need to draw. The environment checks for errors, compiles and executes the code seamlessly, like there is only one type of code.

Prototype and experiment

Visual programming is specially suited for prototyping, experimenting and exploring data. The ability to quickly connect a display to a wire and see what's going on or the possibility to drag and drop a widget to feed some parameter to the system makes the development cycle very fast. Thus Zaluum is specially suited to work with sensors and actuators like robotics, equipment testing, automation, etc. It's also useful to explore other real time data like financials, or complex mathematical models like simulations.

Comfortable environment

Eclipse based

Eclipse is one of the leading open source IDEs (Integrated Development Environment). Zaluum has been developed as an Eclipse plugin. This means that Zaluum is based on a solid grounds and reuses most parts of this platform. Many developers are familiar with Eclipse and the overall user experience is very polished. Zaluum relies on all this experience to build up the visual programming language.

Automatic and incremental compilation

Zaluum compiles the source code automatically, in the background, every time you save a file. Since the compiler is incremental, it only builds the files you have modified and their dependencies. The result is that the project is always compiled and ready to run with almost zero waits.

Errors and warnings are updated continuosly as you draw so you always have feedback of whether your program is correct or not. Once it compiles, a single click runs the program.


Being based on Eclipse means that you can use all the Eclipse plugins with Zaluum. There are plugins in the marketplace for almost everything you can imagine. Some examples of useful plugins:

Multi platform

Zaluum runs on all supported Eclipse platforms:

  • Windows
  • Mac
  • Linux

And almost everywhere a Java Virtual Machine 5.0 runs.

Dual view

Design interfaces without writing code

Every Zaluum file has two views. The boxes view is where you add boxes and wires to create the executable part of the program. When you hit the GUI button, the GUI view pops up and shows the visual widgets associated to the boxes. You can layout, configure, and customize the interface directly manipulating the widgets. When the program runs, the interface displays the data being processed by the boxes.

You can use the interface created in one Zaluum file as a widget in another Zaluum file. You can also add new widgets written in Java with a simple annotation in the source code.

Real time data interaction

The generated GUIs are optimized to interact with the underlying data without slowing down the execution. The main progam and the GUI are executed in separated threads and widgets are designed to do not block the main thread. So Zaluum is specially designed for high-throughput and low latency processing.

Configuration wizards

All the boxes and widgets can have a configuration wizard to help the user with the setup. This way the user can manipulate the parameters of the box in an user-friendly way, with customized help, live previews or other aids.

Like widgets and boxes, an advanced user can create her own wizards with a simple annotation and distribute them to other users.

Joint compilation

Mix Java and Zaluum

You can mix Java and Zaluum source files in the same project. The compilation of both kind of sources is. Java is aware of the classes and methods declared in Zaluum files and Zaluum is so about Java. The compilation is a single step, handling the dependencies between Zaluum and Java in a transparent way. This also means that you get all the auto-completion aids usually available in Eclipse for Java. The same way, any change a Java file used in a Zaluum class is immediately picked and displayed.

The ability to mix two different programming paradigms seamlessly leads to unrivaled productivity and expressive power.

Illustration of mixed Java and Zaluum
public void invokingZaluum() {
 	// A Zaluum box used like a class
 	ZaluumBox b = new ZaluumBox();
	// that has 3 inputs and 1 output.
	int result = b.act(2,3,4); 
	System.out.println("result = " + result);


Fast Execution

Zaluum executes the same way as pure Java. This means that your programs take advantadge of the “state of the art” optimizations provided by modern JVMs. Latest versions of JVMs yield near native-code performance and in some cases, thanks to optimizations made on runtime (Hotspot JIT), they outperform it. In cases where heavily optimized native code must be used (e.g. FFT), the JVM can invoke it with native wrappers.

Fast binaries

Zaluum generates efficient Java bytecode and the execution speed is on par with pure Java. No reflection tricks or dynamic invoking mechanisms are used in Zaluum. So there is no performance penalty in using Zaluum.

Automatic parallelization

Zaluum drawings make the data dependencies between boxes explicit. This information can be used to figure out which boxes can be executed in parallel, enabling Zaluum to distribute the work in different threads. All the plumbing is done automatically, with no user intervention. Parallel execution may lead to big performance gains in cpu-intensive tasks but it can also bring performance penalties in simple algorithms due to the synchronization overhead. Zaluum lets you choose when to enable automatic parallelization.

Warning This feature is currently disabled in this Alpha version.

Object oriented

Statically typed object oriented

Zaluum blends two programming language paradigms: Object Orientation and Graphical Dataflow programming. Zaluum is a statically typed language: all the wire and boxes data types are checked at compile time. It allows more errors to be caught early in the development cycle and it can make program execution faster by enabling more optimizations. This static information is also used to provide feedback aids while editing like autocompletion, colorizing the wires, etc.

Automatic Palette discovery

Any Java class and method can be used as a box by Zaluum but to improve the user experience, Java classes can be annotated to add more information for the graphical usage. For example, classes annotated like the one at the right, show up in the palette of boxes, making it more comfortable for the end user.

Example of using annotations to create box classes
import org.zaluum.annotation.*;
@Box // This is one way of declaring this class to show up in the palette 
public class ExampleJavaBox  {
	@Out public float f;
	public int run(int a, int b, Object c) {
		if (c!=null) f=0.5f; // I'm sure you can write something more useful :)
		return a+b;


Access Zaluum boxes as fields and methods from Java. Use any Java class as a Zaluum Box.

Java Zaluum
public class MyClass{
public void method(int a){...}
Zaluum file MyClass.zaluum
Instance new MyClass() A box of class MyClass dragged from the palette

Java Ecosystem

Thousands of libraries available

Leverage the vast range of libraries available as Java Jars. From web services to sofisticated math. Just add them to the project classpath exactly as any other Eclipse Java project.

Use the huge pool resources available to Java programmers: books, tutorials, communities, tools for your project.


Zaluum also provides an Ant task that can be used for offline compilation in external build tools and continous integration environments. Also any tool working at bytecode level works for Zaluum: debuggers, optimizers, obfuscators or for example JRebel that enables you to modify the code without stopping the program.


Zaluum binaries run everywhere a Java Virtual Machine can run:

  • Windows
  • Mac
  • Linux
  • Real time Java
  • Android
Warning Swing GUIs do not run on Android

Zaluum Widgets

Use any Swing widget with Zaluum

All the GUI part is based on the standard Java GUI toolkit Swing. There is no need to learn new toolkits to write your own widgets: you just need to extend the java.awt.Component class and prove some JavaBeans properties to be edited and configured. Any Swing widget can be used by Zaluum.

Zaluum widget collection

Zaluum provides a basic collection of widgets designed for real time data visualization. The plot widget is the most useful, enabling you to draw charts updating in real time. It also provides a wizard to help you with the configuration of the axes, line styles and other options.


Zaluum is published under the Apache License v2.0. This means that both the editor and the runtime are royalty free.

Zaluum tries to provide an alternative and innovative tool to cover the use cases addressed by software packages like NI LabView or Mathworks Simulink among others. At the same time we expect to address new programming challenges such as Hadoop MapReduce or related data mining problems in future versions.

The opennes of Zaluum means that anyone can contribute to expand and improve it.

Available at GitHub

All the source code is available at GitHub. Please visit the Source Code page for instructions on how to download and build the project.

Written in Scala

Zaluum internals are developed using Scala, a high performant, functional, concise, Java-compatible language.

Please participate!

We need feedback to know your problems and needs. What would you like to see implemented in Zaluum? how would you like to use it? Enter the design discusion page and tell us.

Of course, developes are very welcome! Just fork us on GitHub!

Beta to-do list

  • Build a basic palette
  • Figure out how to deal with exceptions in a drawing
  • Better layout and wire routing algorithm.
  • Enhanced visual appearance and ergonomics.
  • Comprehensive test suite.
INFO A more detailed task list is available at GitHub's Wiki and Issues


Some mid/long term ideas of what Zaluum could be used for:

  • Compatibility with other JVM languages: Scala?
  • Better support for code refactoring operations.
  • Provide different semantics for the drawings taking advantadge of the Zaluum-Java compatibility
    • Hadoop map-reduce code generation
    • Simulation
    • Bussiness process management engine
  • Hard real-time Java compatibility.
  • Native code generation. AOT compilation.
  • FPGA VHDL code emission.
  • Want to share yours?

Download Zaluum Alpha »