Qt on Pi – Contribute

QtonPi Platform

With QtonPi platform we aim to provide our community with the tools needed to create awesome Qt 5 Apps on Raspberry Pi hardware. We intend to take a minimalistic approach towards what’s included in the platform and let our App Developers drive the evolution of the platform with real world App use cases.

QtonPi platform is not intended to be another full fledged Linux distribution. While we plan to use packages and tools from other distributions, our goal really is to provide an easy-to-use flexible innovation environment for Qt and Qt related technologies.

We really welcome your contributions to QtonPi platform.

Following are some general principles on which we hope to build QtonPi platform

  • Full cross-build environment for QtonPi stack
  • No GPLv3 packages
  • Clean separation (to the extent possible without excessive over-engineering) of QtonPi packages and Raspberry Pi specific packages
  • Upstream as much as possible and aim to maintain minimal set of necessary changes in QtonPi project

QtonPi Platform consists of the following,

  • SD Card Image
  • Toolchain and Sysroot
  • Qt Creator based App SDK
  • Cross-build tools

QtonPi Roadmap

QtonPi software stack can be broken down into three layers. These layers exits so that folks in the QtonPi community can organize themselves in areas that they’re most passionate about. The layers are,

  1. Base Layer
  2. Middleware
  3. Apps

Base Layer

Base Layer essentially consists of everything above the hardware providing all the enablers to run our middleware. This includes – boot loader, codecs, kernel, root filesystem, RPM packages, compiler, build environment, etc.,


Our middleware consists of Qt 5 (plus additional optional modules where it makes sense) and a Qt Creator based QtonPi SDK for App Creation along with all the community documentation we can put together.

That’s it! Nothing more, nothing less.

The programming models that we will support would be,

  • Qt C++
  • JavaScript

For UI, you can use,

  • QML (or)
  • HTML (though QtWebKit)


Interesting Apps is something that we hope our community will create, so that we can build a better Middleware and Base Layer.

We might have scenarios where we might not be able to provide all the APIs needed for folks trying to do some really cool Apps with QtonPi.

We should however make it easy both at the Base Layer and Middleware for folks to be able to add their own APIs where necessary and provide all the freedom for App Developers innovate.


QtonPi is a community project. Following is a general direction on where we would like to go.


  • Base Layer
    • Fedora RPM Packages plus some additional Raspberry Pi Specific packages
    • Linaro GCC 4.5.4 toolchain
    • QtonPi image creator and sysroot tools
  • Middleware
    • Documentation on how to get toolchain + sysroot + Qt Creator working to Develop Apps
    • Qt 5 running on full-screen EGLFS mode


Target – Spring 2012

  • Base Layer
    • OpenSuse QtonPi Packages (without GPLv3 packages)
    • Build Envrionment
    • Updated Compiler (GCC 4.6)
    • QtProcessManager
    • QtJsonDB (App Development)
  • Middleware
    • QtonPi SDK delivered as an installer with integrated toolchain + community documentation
    • Auto configuration/discovery of Raspberry Pis from QtonPi SDK
    • Qt 5 running on Full Screen EGLFS mode


Target – Summer 2012

  • Base Layer
    • Migrate to a kernel version that supports CMA
    • Update or add packages to support Multimedia and Multi-process Qt/Qt Quick Apps
    • Provide an example compositor environment based on qt-compositor and process manager
  • Middleware
    • Update QtonPi SDK to include the release version of Qt 5
    • Improve community documentation

QtonPi Image Creator and Sysroot

QtonPi releases comes with a default SD Card Image and Sysroot. Following instructions are for you to be able to build your custom SD Card Image and Sysroot.

Download and Installation Requirements

In order to build your custom QtonPi SD Card Image/Sysroot, you’ll need Fedora 14 (as it is the distro most contributors are working on). We hope in subsequent release we can take this dependency away.

Setting up Fedora 14

First please ensure that you’ve all the necessary development tools on your host. You can do this by installing the Development Tools meta-package.

  1. $ sudo yum groupinstall 'Development Tools'

Once this is done, next step would be to install augeas-libs, which is needed to install zypper package.

  1. $ sudo yum install augeas-libs

Installing host-rpms

You will find host-rpms in the following directory.

  1. qtonpi-X.Y/
  2. ├── platform-sdk/
  3. │   ├── host-rpms/

To install, just go into that directory and do an sudo rpm -ivh *

  1. $ pwd
  2. /home/rajiv/qtonpi-0.2/platform-sdk/host-rpms
  3. $ sudo rpm -ivh *rpm

Getting Image Creator and Sysroot scripts

Image Creator and Sysroot tools are shipped as a part of the QtonPi software release in the mt-cross-tools directory which you should find here,

  1. qtonpi-X.Y/
  2. ├── platform-sdk/
  3. │   └── mt-cross-tools/

Creating custom Sysroot

mksysroot-rasp-pi script present in mt-cross-tools directory can be used to build custom sysroot. This script must be run as root user and it needs a file containing a list of RPM packages that you would like to be installed in your sysroot. Default sysroot packages are provided in the file rasp-pi-sysroot-list.default.

  1. $ ./mksysroot-rasp-pi
  2. This script must be run as root
  3. usage: sudo ./mksysroot-rasp-pi RPM_LIST

Note – mksysroot-rasp-pi generates the sysroot at /opt/qtonpi/armv5tel-qtonpi-linux-gnueabi/sys-root. Please make sure that this directory does not exist before running the script.

  1. $ pwd
  2. /home/rajiv/qtonpi-0.2/platform-sdk/mt-cross-tools
  3. $ sudo ./mksysroot-rasp-pi rasp-pi-sysroot-list.default
  4. [sudo] password for rajiv:
  5. ./
  6. ./zypp/
  7. ./zypp/zypp.conf
  8. ./zypp/systemCheck
  9. ./zypp/zypper.conf
  10. ./zypp/repos.d/
  11. ./zypp/repos.d/f14.repo
  12. using the following repos:
  13. # | Alias   | Name                            | Enabled | Refresh
  14. --+---------+---------------------------------+---------+--------
  15. 1 | f14-arm | ARM RPM Repository for Fedora14 | Yes     | No
  16. refreshing the repos, this will take awhile (~ 5min)
  18. [...]
  20. $ ls /opt/qtonpi/armv5tel-qtonpi-linux-gnueabi/sys-root
  21. ./   bin/   dev/  home/  media/  opt/   root/  selinux/  sys/  usr/
  22. ../  boot/  etc/  lib/   mnt/    proc/  sbin/  srv/      tmp/  var/
  23. $

Your newly minted sysroot is now available at /opt/qtonpi/armv5tel-qtonpi-linux-gnueabi/sys-root

Creating custom SD Card Image h3.

Partition Layout h4.

For QtonPi Release 0.x, we’ve organized the SD Card as follows. Assuming your SD Card is on /dev/sdb device.

  1. # fdisk /dev/sdb
  3. Command (m for help): p
  5. Disk /dev/sdb: 1977 MB, 1977614336 bytes
  6. 61 heads, 62 sectors/track, 1021 cylinders, total 3862528 sectors
  7. Units = sectors of 1 * 512 = 512 bytes
  8. Sector size (logical/physical): 512 bytes / 512 bytes
  9. I/O size (minimum/optimal): 512 bytes / 512 bytes
  10. Disk identifier: 0x0000cded
  12.    Device Boot      Start         End      Blocks   Id  System
  13. /dev/sdb1              62      249611      124775    c  W95 FAT32 (LBA)
  14. /dev/sdb2          249612     2250289     1000339   83  Linux
  15. /dev/sdb3         2250290     3248737      499224   82  Linux swap / Solaris
  17. Command (m for help): q
  19. #

All partitions are primary partitions.

  • The first partition is a Fat32 partition which consists of the secondary bootloader, kernel, and other files needed to be initalize the GPU.
  • The second paritition is a Ext4 partition, where the root filesystem resides
  • The third partition is a swap partition that we’ve thrown in for a good measure. This might be removed in the subsequent releases.

Feel free to resize the partitions depending on the space available on your SD Card. However, we do urge you preserve this layout. You can use Apps such as Disk Utility, fdisk, parted and mkfs to manipulate the partition layout to fit your needs.

Boot Partition h4.

The boot partition must be a FAT32 partition. The contents of this partition is shipped in the file rasp-pi-kernel-3.1-partition.tar.bz2, which is located here,

  1. qtonpi-0.2
  2. ├── platform-sdk
  3. │   ├── image-creator-binaries
  4. │   │   ├── rasp-pi-kernel-3.1-modules.tar.bz2

So, to build your boot partition, all you need to do is to extract the contents of this file onto that partition.

Assuming your boot partition is mounted at /media/boot, you could do something like,

  1. $ cd /media/boot
  2. $ sudo tar jxvf /home/rajiv/qtonpi-0.2/platform-sdk/image-creator-binaries/rasp-pi-kernel-3.1-partition.tar.bz2
  3. [sudo] password for rajiv:
  4. ./
  5. ./arm224_start.elf
  6. ./cmdline.txt
  8. [...]
  9. $

Root Filesystem h4.

The root partition must be an Ext4 partition.

mkrootfs-rasp-pi script present in mt-cross-tools directory can be used to build custom rootfs. This script must be run as root user and it needs a two things.

  1. Pointer to directory where you would like your rootfs to be built
  2. File containing a list of RPM packages that you would like to be installed in your sysroot

Default rootfs packages are provided in the file rasp-pi-rootfs-list.default

  1. $ ./mkrootfs-rasp-pi
  2. This script must be run as root
  3. usage: sudo ./mkrootfs-rasp-pi ROOTFS_DIR RPM_LIST

Now, to build your new rootfs at /tmp/rootfs,

  1. $ pwd
  2. /home/rajiv/qtonpi-0.2/platform-sdk/mt-cross-tools
  3. $ sudo ./mkrootfs-rasp-pi /tmp/rootfs rasp-pi-rootfs-list.default
  4. [sudo] password for rajiv:
  5. using the following repos:
  6. # | Alias   | Name                            | Enabled | Refresh
  7. --+---------+---------------------------------+---------+--------
  8. 1 | f14-arm | ARM RPM Repository for Fedora14 | Yes     | No
  9. refreshing the repos, this will take awhile (~ 5min)
  11. [...]
  13. unpacking the etc files
  14. unpacking the kernel modules
  15. unpacking the gles libs
  16. unpacking qt5
  17. $ ls /tmp/rootfs
  18. ./   bin/   dev/  home/  media/  opt/   root/  selinux/  sys/  usr/
  19. ../  boot/  etc/  lib/   mnt/    proc/  sbin/  srv/      tmp/  var/
  20. $

Your newly minted rootfs is now available at /tmp/rootfs. You can now copy over this directory over to the rootfs partition on the SD Card. Assuming your rootfs partition is mounted at /media/root, you can do the following,

  1. $ sudo rsync -av /tmp/rootfs/* /media/root/
  2. [sudo] password for rajiv:
  4. [...]
  6. var/tmp/
  7. var/yp/
  9. sent 503804268 bytes  received 250274 bytes  9082063.82 bytes/sec
  10. total size is 502887293  speedup is 1.00
  11. $ ls /media/root
  12. ./   bin/   dev/  home/  lost+found/  mnt/  proc/  sbin/     srv/  tmp/  var/
  13. ../  boot/  etc/  lib/   media/       opt/  root/  selinux/  sys/  usr/
  14. $

Your SD card is now ready with custom QtonPi image for use on Raspberry Pi.

Updating mt-cross-tools h3.

mt-cross-tools repository which is available on Gitorious [qt.gitorious.org] or Gerrit [codereview.qt-project.org].

Note – You will need to clone mt-cross-tools into the platform-sdk/ subdirectory of your QtonPi release.

  1. $ pwd
  2. /home/rajiv/qtonpi-0.2/platform-sdk
  3. $ git clone git://gitorious.org/qtonpi/mt-cross-tools.git
  4. Cloning into mt-cross-tools...
  5. remote: Counting objects: 64, done.
  6. remote: Compressing objects: 100% (56/56), done.
  7. remote: Total 64 (delta 20), reused 0 (delta 0)
  8. Receiving objects: 100% (64/64), 34.68 KiB, done.
  9. Resolving deltas: 100% (20/20), done.

After cloning, your relative directory structure should look as follows,

  1. qtonpi-X.Y/
  2. ├── platform-sdk/
  3. │   └── mt-cross-tools/