Igelle for the Masses: A First Look

A different distro

There are hundreds of different Linux distributions worldwide. However, almost all of them are based on Debian, openSUSE, Slackware or Red Hat. But is there a distribution with unique features that is not based on any other grand distro… — one that has the flexibility of a regular Linux flavour? It turns out there is — please meet the Igelle!

My first acquaintance with this distribution was quite unusual. The thing that caught my eye was an artistic graphical design of BarPanel — the desktop panel, which is written in Python, and can be used with any Linux distribution. Being curious, I tried to figure out what other products are made in a similar manner, and by a similar developer.

As it turned out, there were other software made to be used by Igelle DSV: Melas, a build and packing tool; the Ige Package Manager, and Igelle Connector. This distribution has been declared as a general-purpose operating system for desktop computers, laptops, netbooks and servers. I’ve spent some time and explored it with my work laptop, as well as with a desktop PC, and even with my MIPS netbook. It works almost flawlessly.

Okay, let’s proceed to a real experience. Let’s take the ISO image from Igelle’s website, burn it to a CD-ROM and try to boot any x86 machine.

First look

The initial bootstrapping is as usual — first the Linux kernel with an initramfs image loads into memory, and then the hardware is initialised. After a minute, you’ll get a working desktop based on LXDE. Visually, it looks like a contemporary distribution (Figure 1). However, let’s dig a little bit deeper, and figure out how it really works.

First look at Igelle DSV at LiveCD mode

Figure 1: First look at Igelle DSV at LiveCD mode

The distribution can be installed from LiveCD mode in a minute

Figure 2: The distribution can be installed from LiveCD mode in a minute

I’ve installed Igelle DSV into a virtual machine first, and allocated 1 GB of virtual hard disk space for it, just to see how it works. Don’t be surprised that the root partition appears so small. In fact, this is quite a large space, and Igelle can live with it quite happily, despite it being a full installation:

$ df -h
Filesystem            Size  Used Avail Use% Mounted on
rootfs               1008M  620M  338M  65% /
udev                  506M  1.1M  505M   1% /dev
none                 1008M  620M  338M  65% /
/dev/sda1            1008M  620M  338M  65% /igelleroot
/var/run              506M   40K  506M   1% /var/run
/var/lock             506M     0  506M   0% /var/lock
/dev/shm              506M   88K  506M   1% /dev/shm
none                 1008M  620M  338M  65% /var/spool/cups

The df -h command shows that the /dev/sda1 partition is mounted at /igelleroot, where the GRUB loader stores its components. There is another subdirectory that hides here — igelle/1.0.0. This contains a big SQUASHFS image file, together with the Linux kernel for this Igelle release, and an initramfs disk as well. This concept isn’t quite new, and it is used among many popular Live CDs, like Knoppix.

anton@DSV_100:~$ ls -l /igelleroot/
total 24
drwxr-xr-x 3 root root  4096 Apr 15 08:49 boot/
drwxr-xr-x 4 root root  4096 Apr 15 08:57 igelle/
drwx------ 2 root root 16384 Apr 15 08:49 lost+found/

anton@DSV_100:~$ ls -l /igelleroot/igelle/1.0.0/
total 600888
-rw-r--r--  1 root root  14751413 Feb 18  2010 initramfs
drwxr-xr-x 13 root root      4096 Apr 15 10:16 overlay/
-rwx------  1 root root 598695936 Feb 18  2010 rootfs*
-rw-r--r--  1 root root   1848784 Feb 18  2010 vmlinuz

It’s possible to have multiple versions of Igelle DSV stored on disk. Once the root filesystem (the file itself is named rootfs) is mounted in read-only mode, an additional overlay subdirectory is being mounted as an AUFS device, where all the changes to / will be written. Igelle’s root filesystem is thus actually a mix of read-only SQUASHFS images, and the AUFS overlay directory:

rootfs on / type rootfs (rw)
udev on /dev type tmpfs (rw,relatime,mode=755)
/sys on /sys type sysfs (rw,relatime)
/proc on /proc type proc (rw,relatime)
none on / type aufs (rw,relatime,si=8da72793)
/dev/sda1 on /igelleroot type ext4 (rw,relatime,barrier=1,data=ordered)
/var/run on /var/run type tmpfs (rw,nosuid,nodev,noexec,relatime,mode=755)
/var/lock on /var/lock type tmpfs (rw,nosuid,nodev,noexec,relatime)
/dev/shm on /dev/shm type tmpfs (rw,relatime)
/dev/pts on /dev/pts type devpts (rw,relatime,gid=5,mode=620)
none on /proc/bus/usb type usbfs (rw,relatime)
none on /var/spool/cups type aufs (rw,relatime,si=8da72793)
gvfs-fuse-daemon on /home/anton/.gvfs type fuse.gvfs-fuse-daemon (rw,nosuid,nodev,relatime,user_id=1000,group_id=1000)

Why is this approach (using an overlay and hybrid storage) so good? First, you’re left with an intact and consistent root filesystem. All changes made in /usr, /var, /etc, are actually stored separately. Remove the overlay, and the system returns to its original state, with default settings.

Second, you can simultaneously have multiple versions of Igelle distributions on the same disk partition, because settings for each release are stored in individual folders. For example, version 1.0.0 is located at the absolute location /igelleroot/igelle/1.0.0, while the next version will have its settings stored in /igelleroot/igelle/2.0.0. Moreover, you can place multiple Igelle versions along with any preinstalled Linux distro — there’s no need to remove it, or repartition. Just don’t forget to add a line to the GRUB loader configuration, /igelleroot/boot/grub/grub.cfg.

Igelle’s architecture

Figure 3: Igelle’s architecture

Configuration

The first thing every novice tries to do with a new environment is to set it up in the most comfortable way. Of course, the widget that catches your eye is a translucent panel at the bottom of the desktop — a la Apple Macintosh. This is an Esther-Panel — a part of the Igelle project (Figure 4).

The Esther-panel application resembles Apple’s Macintosh quick- launch

Figure 4: The Esther-panel application resembles Apple’s Macintosh quick- launch

In order to add a new entry to Esther-Panel (a.k.a. Quick-Launch), just run LXTerminal (Igelle –> Applications –> Command line) and make a symbolic link from the necessary GNOME application profile to the ~/.local/share/favorite-applications directory:

$ ln -s /usr/share/applications/brasero.desktop ~/.local/share/favorite-applications/

The panel must be restarted after this, with something like killall esther-panel. After that, the new application is added to the panel.

By default, all programs are displayed in English. However, sometimes you may need national language support. To have localisation applied to the desktop (for example, the French language), simply run the following commands:

# mkdir /usr/lib/locale
# localedef -ci fr_FR -f UTF-8 fr

When you launch the calculator application with the LANG environment variable set to “fr” (LANG=fr galculator), you’ll see its menus in French. However, to make the full desktop appear in French, by default, you should add the following line into ~/.config/esther-session.config:

esther-session-control setenv LANG fr

All GNOME applications used by the system expect to have localisation files for each language. If you correctly configured your language, but an application is still displayed in English, then this means that your particular application has no translation file yet; this job still needs to be done by the translation team.

What about input in a local language? That’s easy — place the following command into a startup script (for example, .bashrc in your home directory), and you can now switch between US and Arabic keyboards by pressing both Shift keys:

setxkbmap -option grp:switch,grp:shift_toggle,grp_led:scroll us,ar

Self-contained packages

What is a self-contained package, and why is it needed? Imagine that you have a package called MyEditor. It keeps all files (localisation files, dynamic libraries, icons and so forth) in one specific location — say, /opt/MyEditor. Is it comfortable? Very! Besides, you have an opportunity to install and uninstall this package from the system in the blink of an eye, just like the mount/umount commands, but in this case, using the sjdctl command.

By default, the Igelle system has bleeding-edge software only, like the latest X11 libraries (and those that developers require), GNOME and QT, and the GCC compiler — that’s why when you run Igelle, you can compile any application from source. For example, in Live CD mode, I was able to compile MPlayer, rdesktop and vncviewer, from scratch. This definitely helped me a lot when I faced an emergency situation.

To view a full list of packages that are preinstalled in the rootfs, use: Igelle –> About this system –> Packages.

The CD image’s contents are limited by size (650 MB) and unfortunately, some much-required applications like Kino, AbiWord or VLC weren’t included. However, you can find them in a special repository. All you need is to download files with the sjapp extension, and install it. Alternatively, you can download a specification file only (with an sjs extension), which describes how the package should be built, and create a binary package by yourself.

A specific package that can’t be found even in this repo has to be built manually. In one particular case, I preferred using a file manager like Midnight Commander. I decided to compile the package for it first, and place it in the /opt/mc directory (exactly where an mc binary package would be installed). In order to compile the binary package, you might need to be familiar with the meta-compiler syntax, and how to correctly edit a package description. Let’s look at the mc-4.7.1.sjs file:

mc: sjapp {
        setself "url" "http://www.midnight-commander.org/downloads/35"
        setself "version" "4.7.1"
configure() {
      ./configure --with-screen=ncurses --prefix=/opt/mc --datarootdir=/opt/mc/share --localedir=/opt/mc/locale --libexecdir=/opt/mc/libexec --sysconfdir=/opt/mc/etc/
}
compile() {
      make
}

install() {
                rm -rf "`getself staging`"
                mkdir -p "`getself staging`/`getself prefix`"
                make DESTDIR="`getself staging`" install

                mkdir -p "`getself staging`/`getself prefix`/share/applications";
                cat > "`getself staging`/`getself prefix`/share/applications/mc.desktop" <<EOF
                        [Desktop Entry]
                        Name=Midnight Commander
                        Exec=lxterminal -e /opt/mc/bin/mc
                        Icon=/usr/share/icons/gnome/32x32/devices/gtk-floppy.png
                        Terminal=true
                        Type=Application
                EOF
}
}

Here’s a brief comment on the functions and variables used. At the beginning, you need to declare the metapackage name (mc: sjapp {... here comes the body ... }). Then declare a version for this new package (setself version 4.7.1) and the location of the source code — (the statement setself url). After that, define the functions configure(), compile(), and install(), which as the names imply, will be transferred to the make program.

After editing the .sjs file, you need to run a meta-compiler named sjappc (the command is sjappc mc-4.7.1.sjs). After a while, the sjappc meta-compiler generates a binary package for Midnight Commander, invoking the GCC compiler to compile the application. The binary package is, in fact, a SQUASHFS file, which you can safely install into the system by issuing the following command:

# sjdctl install-app mc.sjapp

You can now run Midnight Commander directly, through LXTerminal, specifying the full path to the binary, /opt/mc/bin/mc. Or you can click on the icon with the floppy disk, titled Midnight Commander.

Midnight Commander compiled and deployed within Igelle DSV

Figure 5: Midnight Commander compiled and deployed within Igelle DSV

A more complicated SJS description file would be for the Opera Web browser. Since this browser is not an open source product, you need to remove the compile() and configure() functions. On the other hand, the install() function has now become longer:

opera : sjapp {
        setself "url" "http://snapshot.opera.com/unix/labs-6177/opera-10.50-6177.linux.i386.tar.gz"
        setself "version" "10.50"

        install() {
                rm -rf "`getself staging`"
                mkdir -p "`getself staging`/`getself prefix`"

                cp -R "`getself workdir`"/usr/* "`getself staging`/`getself prefix`"

                mkdir -p "`getself staging`/`getself prefix`/bin";
                cat "`getself workdir`/opera" | \
                        sed s@^OPERA_BINARYDIR=usr/lib/opera@OPERA_BINARYDIR=/opt/opera/lib/opera@g | \
                        sed s@OPERA_DIR=\"\$PWD/usr/share/opera\"@OPERA_DIR=/opt/opera/share/opera@g > \
                        "`getself staging`/`getself prefix`/bin/opera"
                cp "`getself staging`/`getself prefix`/bin/opera" /home/ab
                chmod a+x "`getself staging`/`getself prefix`/bin/opera";


                mkdir -p "`getself staging`/`getself prefix`/share/applications";
                cat > "`getself staging`/`getself prefix`/share/applications/opera.desktop" <<EOF
                        [Desktop Entry]
                        Name=Opera 10.50
                        Exec="`getself prefix`/bin/opera"
                        Icon=/opt/opera/share/icons/hicolor/32x32/apps/opera.png
                        Terminal=false
                        Type=Application
                        Categories=Application;Game;
                EOF
        }
}

After a meta-compilation process, mount the package, and then Opera is ready to be used!

A little more patience is required to build the Chromium browser, because it needs three to four more auxiliary libraries that are used only by Chromium. However, nothing is impossible! See Figure 6 for more details.

Open-source browser Chromium runs smoothly in Igelle DSV

Figure 6: Open-source browser Chromium runs smoothly in Igelle DSV

Future versions

Time does not stand still, and Igelle will develop further. New features and capabilities will be added, so it can run on multiple hardware platforms — not just x86, but also ARM and MIPS laptops. In particular, there was recently a logical bifurcation of the Igelle project into several key areas: mobile systems, servers/desktop systems, and embedded appliances — named Igelle Dash, Igelle Spark and Igelle Pulse, respectively.

There was also an interior redesign of the system’s architecture. Now, if you decide to create a fully portable Igelle application or package, it will be tied to the special library libigelle. This library alone will later decide exactly what resources are needed for this application, and dynamically reroute the necessary requests to the required underlying libraries (see Figure 7).

Future Igelle’s architecture

Figure 7: Future Igelle’s architecture

What seems interesting though is a Wine suite integrated into the Igelle Pulse distribution, the primary focus of which is x86 desktops and servers. Having the Wine emulating layer allows users to run many Windows applications smoothly. Very often, many Windows programs still have no equivalent in the Linux world; so this feature seems especially attractive to users who’ve migrated.

Most newbie Linux users expect several simple things from a general distribution: preinstalled office/network/collaboration applications to start with; a flexible and configurable environment; the presence of a pool of prepackaged applications; as well as an ability to boot the system in a live mode. At the same time, to keep the distribution truly Linux, it must be LSB-compatible, and support multiple hardware platforms: x86, ARM, MIPS, PowerPC and others.

The Igelle distribution was created in an effort to offer users just such a flexible working environment. With a vanilla GNU/Linux kernel and a stack of GNU/OSS applications, it’s generally capable of running on all major hardware platforms that the current Linux kernel supports. Those applications that aren’t yet in a pool of prepackaged applications can be easily compiled with GCC, packaged with sjdctl, and mounted or unmounted, on the fly. Since Igelle provides a built-in GCC environment, every user, from the novice to the highly experienced, can easily and quickly transform their installation to suit their preferences.

Igelle’s overlay mechanism lets you have a single distributed, basically packaged and unmodified ISO file, with transparently mounted software “upgrades”. Igelle can be installed on a freshly reformatted media, or a single ISO file can be placed on an existing filesystem. The overlay concept allows for two booting modes: the normal and “live” mode. The latter helps restore systems from an inconsistent/damaged state. This concept also allows users to access/keep personal data on already existing partitions — again, the maximum flexibility.

In short, Igelle really delivers you the flexibility to tailor your system as you please!

  • Namit Kothari

    Nice! Any performance benchmarks?

  • Saurabh Bhatia

    I liked the change in blog format, the new design looks pretty good

  • Mallik Soupati

    I tried it. I liked it. It was good. But, what I cant take is that, it keeps you behind the time for the packages. I dont like to keep using firefox 4 when there is 9 already available.

  • Jeff Rader

    Distrowatch lists igelle as discontinued.

  • Jeff Rader

    And that iso is from early 2010. That company has moved on. Their current OSs are Dash and Pulse.

  • Jeff Rader

    (I just noticed that this article was written in June 2011)

All published articles are released under Creative Commons Attribution-NonCommercial 3.0 Unported License, unless otherwise noted.
Open Source For You is powered by WordPress, which gladly sits on top of a CentOS-based LEMP stack.

Creative Commons License.