Qt on Pi Contribute

From Qt Wiki
Revision as of 15:10, 14 January 2015 by Maintenance script (talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

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. Once this is done, next step would be to install
, which is needed to install


You will find
in the following directory. To install, just go into that directory and do an
sudo rpm -ivh *

Getting Image Creator and Sysroot scripts

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

Creating custom Sysroot

script present in
directory can be used to build custom sysroot. This script must be run as
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
. Note –
generates the sysroot at
. Please make sure that this directory does not exist before running the script. Your newly minted sysroot is now available at

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

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
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
, which is located here,

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
, you could do something like,

Root Filesystem h4.

The root partition must be an Ext4 partition.

script present in
directory can be used to build custom rootfs. This script must be run as
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
Now, to build your new rootfs at
, Your newly minted rootfs is now available at
. You can now copy over this directory over to the rootfs partition on the SD Card. Assuming your rootfs partition is mounted at
, you can do the following,

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

Updating mt-cross-tools h3.

repository which is available on Gitorious [qt.gitorious.org] or Gerrit [codereview.qt.io]. Note – You will need to clone
into the
subdirectory of your QtonPi release.

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