Melas is a generic build assistant tool, which can make this procedure quite easy in some scenarios, given the right mls file that describes the procedure. This post explains how to easily make a gcc cross-compiler with Melas using an existing mls definition file.

Prerequisites

• A working GNU C Compiler (gcc) setup for your host machine that can produce functioning executables
• An active internet connection to download the necessary source code files
• Melas installed on your computer, and mls-build in your path.

To install Melas, download and install the latest version first from the Melas project page.

Toolchain versions

A complete GCC (cross-)compiler toolchain consists of a number of components; namely binutils, gcc itself, and libc (usually glibc or uclibc). Each of these is released and versioned separately, and sometimes a specific mix/match of these is preferred or required. Luckily, the procedure to build is often roughly the same, and hopefully no great differences will be introduced by different versions. The exact versions to build can be configured in the mls file, a sample of which can be downloaded from the Melas project site at http://melas.ossproject.org/gcc4-cross.mls (this one is borrowed from the Igelle OS source tree).

As of this writing, the above file defaults to the following versions:

• Binutils 2.18
• GCC 4.2.4
• Glibc 2.7
• uClibc 0.9.29 (experimental)

As mentioned, uClibc support in the mls file is experimental, and may not work properly. All patches are obviously quite welcome to correct any issues :). If other versions are preferred, this can be achieved by editing the mls file accordingly.

Target architecture

Since we are building a cross-compiler, it is essential to be aware of the target architecture, which is usually expressed by a “target tuple”, eg. “i486-unknown-linux-gnu”, or “armv4t-unknown-linux-gnueabi”, etc. Any suitable target architecture can be chosen for this procedure, although much of them haven’t probably been tested. All feedback for this will be most welcome.

The supplied mls file has a particular speciality, though: if the string “uclibc” is supplied as part of the tuple, then a uclibc toolchain build is attempted. Otherwise, a glibc build is assumed. This allows, for instance, tuples like “armv4t-uclibc-linux-gnueabi” or “i486-uclibc-linux-gnu” to be used as targets for uclibc -based toolchains.

Executing the build

Once all the issues above have been considered and addressed, executing the actual build is quite easy:

GCCARCHTUPLE=your-arch-tuple mls-build --run=rebuild \
    http://melas.ossproject.org/gcc4-cross.mls

Here, you must obviously substitute the “your-arch-tuple” to your desired tuple, as mentioned above. Then sit back and relax, this will take quite some time, but happily the whole process is managed for you (binutils get compiled, then a bootstrap gcc, then libc, then gcc again, etc.).

Obviously, if you have downloaded the mls file and made your own modifications, you must point mls-build to your modified mls file instead of the URL above.

The end-result

After a successful build, you will end up with a .deb file in your current directory representing your full cross-compiler toolchain. This is complete with gcc, g++, binutils (linker, assembler, etc.), as well as header files and link libraries for developing working binaries for the target.

(You can actually even extract the whole libc from within the packet to deploy on the target to make a running system, however if this is what you are after, it is probably best to look at Igelle, which includes a build system (based on Melas also) to make a complete functioning Linux system.)

Then, simply install the .deb file and start using the new cross-compiler; handy links are installed in /usr/bin so that the compiler is automatically in your PATH. Simply run [your-arch-tuple]-gcc to compiler, eg.

armv4t-glibc-linux-gnueabi test.c -o test-arm

(to compile an ARM program).

Expected issues

As mentioned, uclibc support has not been tested, and probably doesn’t work well on all targets. Similarly, different versions of the toolchain components have not been tested. All feedback on any successes, failures or other experiences is most welcome, as well as obviously initiatives for further improvements on this.

• Command line interface
• GTK+ -based graphical user interface
• Wired ethernet connections
• Wireless LAN
• Fixed and automatic IP address (DHCP) support
• GSM/3G Wireless data connections
• Bluetooth wireless modem support

Installation packages are provided in DEB and tar.bz2 form, and are available under the download section of the project site. Screenshots are also available. The software can be installed alongside an existing network manager (such as NetworkManager or wicd) without any problems, but will probably collide with other network managers in runtime if configuring the same interfaces. Regardless, installing and testing IC does not necessarily require uninstallation of any existing network managers.

All feedback and testing are most welcome.

The site aims to be a collection of useful information for those who are starting out in (open source) software development, or wish to learn more and/or keep up-to-date. New content submissions are highly welcome, as well as any comments and suggestions for improvement.

Happy developing!

BarPanel v0.4.0 adds a number of new features and fixes to the panel:

New features/plugins:

• staticmenu: A static menu of launchers (customizable via the config file)
• windowmenu: An experimental window menu plugin: requires a recent libwnck-python
• battery: A battery status plugin (requires HAL)

Fixes and adjustments:

• New default configuration to reflect some of the new features
• If available, provide an easy way to start the Alacarte menu editor
• Ability to reload configuration on request (SIGHUP)
• Fixed popups that overflow from right side of the screen
• The web search textbox was made white
• Added a “search” button in the web search popup window
• Now handles ‘%u’ and ‘%f’ handling in desktop files properly
• Allow reloading of configuration (and menus) through the GUI
• Sticky flag set properly to (hopefully) keep the panel visible on all virtual desktops

Known (big) issues:

• The embedder plugin is not completely implemented
• Should provide graphical feedback when reloading config
• No graphical configuration interface is yet available

Initial testing of this has been done on Ubuntu 7.04, Ubuntu 8.04 and Igelle (git head). Please post any further testing results as comments below as necessary.

For downloads and more information, please proceed to the BarPanel project page.

Ige has been a part of the Igelle operating system for some time now; at this time, it is now also released properly as a standalone project. Ige is a very small, very simple, but very usable and powerful software package manager tool that can do various things:

* Installation, removal and updating of software packages
* Fully compatible with deb and ipk formats
* Automatic dependency resolution
* Local or HTTP -based installations
* Very small in terms of code and footprint

“Very small” above relates currently to 943 lines of C code, and ~42kb compiled binary on i386 and ~16kb compiled binary on ARMv4t. It does depend in runtime on some standard utilities, such as gzip, tar and wget (for HTTP support).

Code is still early and surely has bugs and issues remaining - regardless, it is mature enough for everyday use and has been used as the package manager of Igelle for some time already. All testing and comments are, as usual, highly appreciated.

For downloads and more information, please refer to the Ige project site.

• Igelle, http://www.ossproject.org/projects/igelle
• BarPanel, http://www.ossproject.org/projects/barpanel
• Melas, http://www.ossproject.org/projects/melas

At the same time, the old project sites under www.igelle.org were changed to simply link to the new addresses. Please update your bookmarks accordingly.

www.igelle.org will then be the official homepage for resources related to the Igelle operating system. Obviously, this blog remains at www.igelle.net

All of this is new, so please inform of any troubles with these new arrangements.

The downside? Midori and WebKit are both non-stable, rapidly changing softwares and no binary packages are really available for either. Numerous instructions exist for how to compile these, though. Here’s one more to add to that list, but this time using Melas; and you actually get .deb packages that you can then remove and/or upgrade. These instructions, therefore, assume a .deb -based system. This was tested on Ubuntu 7.04, but shouldn’t (hopefully) be much different for any other recent Ubuntu.

1. Build dependencies

Usual build essentials (compiler, etc.) should obviously be present, as well as a number of development packages. These should be installable via (under Ubuntu or other apt-get -based systems — also, you will probably need to have the universe repositories enabled);

sudo apt-get install build-essential libcurl3-dev \
    libicu36-dev libgtk2.0-dev libsqlite3-dev \
    libfreetype6-dev libxslt1-dev libsexy-dev \
    libxml2-dev

2. Install Melas

Install the latest Melas package available from the Melas project site.

3. Make a build directory

Execute your build in an empty directory created for this purpose, eg.;

mkdir midori
cd midori

4. Build and install WebKit

Build WebKit with the following command:

mls-build http://www.igelle.org/mk/webkit.mls --run=rebuild

The install with your favourite package manager, eg.;

sudo dpkg --install webkit*.deb

5. Build and install Midori

Then build Midori itself:

mls-build http://www.igelle.org/mk/midori.mls --run=rebuild

And again install with your favourite package manager, eg.;

sudo dpkg --install midori*.deb

The browser should then appear in your application menus, and/or can be started from the command line as

/usr/bin/midori

Happy browsing!

1. Install dfu-util

You can download a readily compiled deb file for dfu-util (for i386) from the Igelle project site, and install as usual (where dpkg applicable, of course);

sudo dpkg --install dfu-util_4448_i386.deb

In case the deb file doesn’t work for you, or if you can’t work with debs, you can also get dfu-util straight from the OpenMoko site.

2. Download the installers

Again, download the latest FIC GTA01 files from the Igelle project site. As of now you’ll need two files: the kernel (*.uImage) and the root filesystem image (*.jffs2).

3. Prepare your Neo

Power up the Neo in bootloader mode (press AUX and Power simultaneously). Once in bootloader, connect it to your PC/laptop via a USB cable.

4. Flash the images

Flashing the images can be done as follows;

sudo dfu-util -a kernel -R -d 1457:5119 \
    -D linux-ficgta01_*.uImage

and

sudo dfu-util -a 5 -R -d 1457:5119 \
    -D igelle-ficgta01-image_*.jffs2

Once finished, detach the USB cable and choose “Boot” from the Neo’s boot menu (or power off and on to start from scratch).

Igelle v0.4.1 is a minor version release over v0.4.0 (due to only small differences in the code), however the release is a major one in that the first images for an ARM device are released here. New in this release is initial support for the FIC NEO1973 OpenMoko phone, together with a fully compilable array of packages for the armv4t architecture used by the device. No notable differences for other platforms in this release.

(Note that the NEO images in this release are still incomplete in features, and not really usable for any real task, however they do work well and look beautiful.)

As usual, proceed to the Igelle project site for downloads and installation instructions.

Installable binaries with installation instructions will be posted after some stabilization and feature richness has been achieved. In the meantime, please take a look at the screenshots.