Disclaimer: Limba is still in a very early stage of development. Bugs happen, and I give to guarantees on API stability yet.
Limba is a very simple cross-distro package installer, utilizing OverlayFS found in recent Linux kernels (>= 3.18).
As example I created a small Limba package for one of the Qt5 demo applications, and I would like to share the process of creating Limba packages – it’s quite simple, and I could use some feedback on how well the resulting packages work on multiple distributions.
I assume that you have compiled Limba and installed it – how that is done is described in its README file. So, let’s start.
1. Prepare your application
The cool thing about Limba is that you don’t really have to do many changes on your application. There are a few things to pay attention to, though:
- Ensure the binaries and data are installed into the right places in the directory hierarchy. Binaries must go to $prefix/bin, for example.
- Ensure that configuration can be found under /etc as well as under $prefix/etc
This needs to be done so your application will find its data at runtime. Additionally, you need to write an AppStream metadata file, and find out which stuff your application depends on.
2. Create package metadata & install software
Now you can create the metadata necessary to build a Limba package. Just run
cd /path/to/my/project lipkgen make-template
This will create a “lipkg” directory, containing a “control” file and a “metainfo.xml” file, which can be a symlink to the AppStream metadata, or be new metadata.
Now, configure your application with /opt/bundle as install prefix (-DCMAKE_INSTALL_PREFIX=/opt/bundle, –prefix=/opt/bundle, etc.) and install it to the lipkg/inst_target directory.
1.2 Handling dependencies
If your software has dependencies on other packages, just get the Limba packages for these dependencies, or build new ones. Then place the resulting IPK packages in the lipkg/repo directory. Ideally, you should be able to fetch Limba packages which contain the software components directly from their upstream developers.
Then, open the lipkg/control file and adjust the “Requires” line. The names of the components you depend on match their AppStream-IDs (<id/> tag in the AppStream XML document). Any version-relation (>=, >>, <<, <=, <>) is supported, and specified in brackets after the component-id.
The resulting control-file might look like this:
Format-Version: 1.0 Requires: Qt5Core (>= 5.3), Qt5DBus (>= 5.3), libpng12
If the specified dependencies are in the repo/ subdirectory, these packages will get installed automatically, if your application package is installed. Otherwise, Limba depends on the user to install these packages manually – there is no interaction with the distribution’s package-manager (yet?).
3. Building the package
In order to build your package, make sure the content in inst_target/ is up to date, then run
lipkgen build lipkg/
This will build your package and output it in the lipkg/ directory.
4. Testing the package
You can now test your package, Just run
sudo lipa install package.ipk
Your software should install successfully. If you provided a .desktop file in $prefix/share/applications, you should find your application in your desktop’s application-menu. Otherwise, you can run a binary from the command-line, just append the version of your package to the binary name (bash-comletion helps). Alternatively, you can use the runapp command, which lets you run any binary in your bundle/package, which is quite helpful for debugging (since the environment a Limba-installed application is run is different from the one of other applications).
And that’s it! 🙂
I used these steps to create a Limba package for the OpenGL Qt5 demo on Tanglu 2 (Bartholomea), and tested it on Kubuntu 15.04 (Vivid) with KDE, as well as on an up-to-date Fedora 21, with GNOME and without any Qt or KDE stuff installed:
I encountered a few obstacles when building the packages, e.g. Qt5 initially didn’t find the right QPA plugin – that has been fixed by adjusting a config file in the Qt5Gui package. Also, on Fedora, a matching libpng was missing, so I included that as well.
You can find the packages at Github, currently (but I am planning to move them to a different place soon). The biggest issue with Limba is at time, that it needs Linux 3.18, or an older kernel with OverlayFS support compiled in. Apart from that and a few bugs, the experience is quite smooth. As soon as I am sure there are now hidden fundamental issues, I can think of implementing more features, like signing packages and automatically updating them.
Have fun playing around with Limba!
2 thoughts on “How to build a cross-distro package with Limba”
Thanks for all your work in this area. We need something like this in Linux world.
The end result will probably become something like PyPI/CRAN/CPAN, but more generic.
With the “frameworkization” seen in GNOME and KDE (KDE Frameworks 5, GNOME Platform/SDK), it also seems unlikely that we will enter a “dependency hell” with Limba 🙂 (especially since it implements conflict-free dependencies).