At the moment you can build Lumiera, start the standard Lumiera GUI and run the Lumiera test suite. The GUI you start might look like a mockup, but in fact is is the real application; just there isn’t any wiring between GUI, model and core yet. This will remain the state of affairs for the foreseeable future, since we’re developing core components against a test suite with unit and integration tests. Thus, the growth of our test suite is the only visible indication of progress.
This tutorial outlines the fundamental steps required to compile Lumiera on
Linux (or a comparable) system. We’ll assume that you have a certain familiarity
with commandline survival skills on your system. To help you getting started,
this tutorial lists all the necessary commands explicitly.
[there are some minor differences between the various Debian based distributions, thus the exact version numbers and package names appearing in our example commands might be slightly different on your system]
There are two distinct methods to build:
use the Debian source code package of Lumiera (the »Debian way«)
use Git to retrieve all source code and build the »classical way«
|just compiling Lumiera on a Debian-based system (e.g. Mint, Ubuntu…)
is much simpler when using the Debian source package. See the separate
tutorial page for this
[besides, there is a separate page with general instructions for installing on Debian/Ubuntu).]
The purpose of this tutorial here is to show you the elementary and generic steps to compile Lumiera from source.
To build Lumiera, you’ll need a build environment together with the
development packages of the libraries Lumiera depends on.
[there is a separate documentation page listing the build dependencies explicitly. We’ll try to keep that information up to date — but in the end, the really authoritative information about the build dependencies is encoded into the build system. Thus, when the build system aborts, indicating that a never version of some library is required, then usually the build system is right…]
More specifically, you’ll need the GNU C/C++ compiler with C++14 support (Version >= 4.9) in addition to the following tools and libraries:
The GUI depends on the following:
|there are known problems with GCC-5.x as of 11/2015
on recent distributions (Ubuntu/wily, Debian/stretch) you might encounter failing tests.
[these problems aren’t really serious; basically we’re sometimes checking mangled class/type names, and seemingly the mangling behaviour of GCC has changed slightly. We’re working on that…]
|Generally speaking, when you want to build software, you’ll need the
development version of the packages that contain the headers and pre-built
libraries to link against. These packages are usually named
For Debian based systems, e.g. Mint, Ubuntu…, you can install these packages as follows:
sudo apt-get install build-essential scons git-core valgrind intltool \ libboost-dev libboost-program-options-dev libboost-regex-dev libboost-filesystem-dev \ libgavl-dev libgtkmm-3.0-dev libgdl-3-dev librsvg2-dev libxv-dev
some people reported you need to install the
intltool package from the standard
Ubuntu repository (for this reason it is included in the above collection)
we really need the gcc-4.9, so building on these platforms is a bit tricky. See our »Backporting« page for detailed info…
we’re aware of some changes in mangled names (or type-IDs), which cause some tests to fail. Other than that, compilation worked for us.
You’ll need to check out the source code in some directory or other. You’ll also have to use this directory to build Lumiera. This could be a temporary directory, or some "workspace" directory below your home directory. We’ll refer to this directory as workspace directory .
Now that you have your basic build environment prepared, the next step is to care
for some special libraries required by Lumiera that are not directly part of the
Lumiera project itself, but aren’t readily available through the usual package
manager of the common distributions either.
[we maintain our own Debian package depot at Lumiera.org and provide binary Debian packages for a range of distributions; yet this tutorial strives at showing the basic and generic method for building. Thus we’ll show you here how to build these libraries from source yourself]
Thus, we’ll have to get the source code for these support libraries, build and install them before we’re able to compile Lumiera.
|Note that the following procedures will try to install files into your
base system below
To do so, you’ll need administrative permission for the machine you’re working on. These additions might interfere with other libraries installed by your package manager (if you get into trouble updating your system later on, you might have to manually remove these libraries).
NoBug is an instrumentation and diagnostics library.
Enter workspace direcory as explained above. Get the NoBug source code:
git clone git://git.lumiera.org/debian/nobug
This will create a (sub)directory called nobug that contains source code.
Compile and install NoBug with the following commands:
cd nobug autoreconf -i mkdir build cd build ../configure make sudo make install
The GNOME Docking library is available through your your package manager, but we additionally need the C++ bindings. Since these haven’t made it into the standard repositories yet, we provide a suitable custom package here; the following shows how to build the latter
we rely on GTK-3 and thus need a compatible GDL-3.
git clone git://git.lumiera.org/debian/gdlmm cd gdlmm ./configure make sudo make install
The compile might warn you to add various directories to
/etc/ld.so.conf and then
ldconfig. This will allow your dynamic linker to pick up the newly built
libraries later when you try to start Lumiera. If you don’t want to reconfigure
your system and add
/usr/local/lib to the linker configuration, you may
alternatively just add the directories to your
Either way, check that all libraries are accessible and OK:
sudo ldconfig -v | grep 'nobug'
and you should get a list of the libraries, part of which should look like this:
libnobug.so.0 -> /usr/local/lib/libnobug.so.0.0.0 libnobugmt.so.0 -> /usr/local/lib/libnobugmt.so.0.0.0 libgdl-lum.so.0 -> /usr/local/lib/libgdl-lum.so.0.0.0
or similar. The same applies to other custom libraries you needed to build explicitly for your system. If any of these libraries are not listed, you’ll have to see why before you can continue.
Next, after having built and installed the external libraries, go into the
workspace directory and retrieve the Lumiera source code. Thereafter, build
Lumiera by invoking the scons build
[more options for building with scons can be found via:
scons -h ]
git clone git://git.lumiera.org/LUMIERA cd LUMIERA scons
maybe build and run the test suite by issuing
The build process will take some time, so sit back and relax.
|you do not need to install Lumiera. It will find all files it requires
relative to the directory structure it generates, which is freely relocatable
as a whole. Just invoke the
After the build has finished successfully, you should be able to start Lumiera. Currently, this will bring up the GUI, without any further functionality (!)
You should see something like this:
If you’re a coder, maybe you have found something to improve…?
Contributing to Lumiera is easy, thanks to Git
→ Tutorial Contributing to Lumiera coding