The Yocto Project team is continually verifying more and more Linux distributions with each release. In general, if you have the current release minus one of the following distributions you should have no problems.

For a more detailed list of distributions that support the Yocto Project, see the "Supported Linux Distributions" section in the Yocto Project Reference Manual.

The OpenEmbedded build system should be able to run on any modern distribution that has the following versions for Git, tar, and Python.

Earlier releases of Python are known to not work and the system does not support Python 3 at this time. If your system does not meet any of these three listed version requirements, you can take steps to prepare the system so that you can still use the build system. See the "Required Git, tar, and Python Versions" section in the Yocto Project Reference Manual for information.

This document assumes you are running one of the previously noted distributions on your Linux-based host systems.

Packages and package installation vary depending on your development system and on your intent. For example, if you want to build an image that can run on QEMU in graphical mode (a minimal, basic build requirement), then the number of packages is different than if you want to build an image on a headless system or build out the Yocto Project documentation set. Collectively, the number of required packages is large if you want to be able to cover all cases.

The next few sections list, by supported Linux Distributions, the required packages needed to build an image that runs on QEMU in graphical mode (e.g. essential plus graphics support).

For lists of required packages for other scenarios, see the "Required Packages for the Host Development System" section in the Yocto Project Reference Manual.

     $ sudo apt-get install gawk wget git-core diffstat unzip texinfo gcc-multilib \
     build-essential chrpath socat libsdl1.2-dev xterm
                

     $ sudo apt-get build-dep qemu
     $ sudo apt-get remove oss4-dev
                    

     $ sudo yum install gawk make wget tar bzip2 gzip python unzip perl patch \
     diffutils diffstat git cpp gcc gcc-c++ glibc-devel texinfo chrpath \
     ccache perl-Data-Dumper perl-Text-ParseWords perl-Thread-Queue socat \
     findutils which SDL-devel xterm
                

     $ sudo zypper install python gcc gcc-c++ git chrpath make wget python-xml \
     diffstat makeinfo python-curses patch socat libSDL-devel xterm
                

     $ sudo yum install gawk make wget tar bzip2 gzip python unzip perl patch \
     diffutils diffstat git cpp gcc gcc-c++ glibc-devel texinfo chrpath socat SDL-devel xterm
                

It is recommended that you get the latest Yocto Project files by setting up (cloning in Git terms) a local copy of the poky Git repository on your host development system. Doing so allows you to contribute back to the Yocto Project project. For information on how to get set up using this method, see the "Yocto Project Release" item in the Yocto Project Development Manual.

You can also get the Yocto Project Files by downloading Yocto Project releases from the Yocto Project website. From the website, you just click "Downloads" in the navigation pane to the left to display all Yocto Project downloads. Current and archived releases are available for download. Nightly and developmental builds are also maintained at http://autobuilder.yoctoproject.org/pub/nightly/. One final site you can visit for information on Yocto Project releases is the Releases wiki. However, for this document a released version of Yocto Project is used.

In the development environment you will need to build an image whenever you change hardware support, add or change system libraries, or add or change services that have dependencies.

Building an Image

Use the following commands to build your image. The OpenEmbedded build process creates an entire Linux distribution, including the toolchain, from source.

     $ git clone http://git.yoctoproject.org/git/poky
     $ cd poky
     $ git checkout -b fido origin/fido
     $ source oe-init-build-env
             

     INHERIT += "rm_work"
                 

Take some time to examine your local.conf file in your project's configuration directory, which is found in the Build Directory. The defaults in that file should work fine. However, there are some variables of interest at which you might look.

By default, the target architecture for the build is qemux86, which produces an image that can be used in the QEMU emulator and is targeted at an Intel® 32-bit based architecture. To change this default, edit the value of the MACHINE variable in the configuration file before launching the build.

Three other variables of interest are the BB_NUMBER_THREADS, PARALLEL_MAKE, and BB_NUMBER_PARSE_THREADS variables. By default, the OpenEmbedded build system sets these variables based on the number of processor cores your build host uses. Thus, you typically do not need to uncomment these variables in your local.conf file to gain optimal build times.

Another consideration before you build is the package manager used when creating the image. By default, the OpenEmbedded build system uses the RPM package manager. You can control this configuration by using the PACKAGE_CLASSES variable. For additional package manager selection information, see the "package*.bbclass" section in the Yocto Project Reference Manual.

Continue with the following command to build an OS image for the target, which is core-image-sato in this example. For information on the -k option use the bitbake --help command, see the "BitBake" section in the Yocto Project Reference Manual, or see the "BitBake Command" section in the BitBake User Manual. For information on other targets, see the "Images" chapter in the Yocto Project Reference Manual.

     $ bitbake -k core-image-sato
            

The final command runs the image using the QEMU emulator:

     $ runqemu qemux86
            

If you want to learn more about running QEMU, see the "Using the Quick EMUlator (QEMU)" chapter in the Yocto Project Development Manual.

For information on how to use a pre-built binary, continue reading into the next section. Otherwise, you might be interested in reading the early chapters of the Yocto Project Development Manual.

If hardware, libraries and services are stable, you can get started by using a pre-built binary of the filesystem image, kernel, and toolchain and run it using the QEMU emulator. This scenario is useful for developing application software.

Using a Pre-Built Image

For this scenario, you need to do several things:

     poky-glibc-host_system-image_type-arch-toolchain-release_version.sh

     Where:
         host_system is a string representing your development system:

                    i686 or x86_64.

         image_type is a string representing the image you wish to
                develop a Software Development Toolkit (SDK) for use against.
                The Yocto Project builds toolchain installers using the
                following BitBake command:

                    bitbake core-image-sato -c populate_sdk

         arch is a string representing the tuned target architecture:

                    i586, x86_64, powerpc, mips, armv7a or armv5te

         release_version is a string representing the release number of the
                Yocto Project:

                    1.8.2, 1.8.2+snapshot
            

     poky-glibc-x86_64-core-image-sato-i586-toolchain-1.8.2.sh
                

     $ ~/Downloads/poky-glibc-x86_64-core-image-sato-i586-toolchain-1.8.2.sh
                

     *zImage-qemuarch.bin
     vmlinux-qemuarch.bin

     Where:
         arch is a string representing the target architecture:
                x86, x86-64, ppc, mips, or arm.
                

     core-image-profile-qemuarch.ext3
     core-image-profile-qemuarch.tar.bz2

     Where:
         profile is the filesystem image's profile:
                   lsb, lsb-dev, lsb-sdk, lsb-qt3, minimal, minimal-dev, sato,
                   sato-dev, or sato-sdk. For information on these types of image
                   profiles, see the "Images"
                   chapter in the Yocto Project Reference Manual.

         arch is a string representing the target architecture:
                x86, x86-64, ppc, mips, or arm.
                

     $ source /opt/poky/1.8.2/environment-setup-arch-poky-linux-if

     Where:
         arch is a string representing the target architecture:
                i586, x86_64, ppc603e, mips, or armv5te.

         if is a string representing an embedded application binary interface.
              Not all setup scripts include this string.
                

     $ runqemu qemuarch kernel-image filesystem-image

     Where:
         qemuarch is a string representing the target architecture: qemux86, qemux86-64,
                    qemuppc, qemumips, or qemuarm.

         kernel-image is the architecture-specific kernel image.

         filesystem-image is the .ext3 filesystem image.

                

     $ cd $HOME
     $ source /opt/poky/1.8.2/environment-setup-i586-poky-linux
     $ runqemu qemux86 bzImage-qemux86.bin \
     core-image-sato-qemux86.ext3
                

Set up your Source Directory by using Git to clone the poky repository and then check out the release branch:

     $ cd ~
     $ git clone git://git.yoctoproject.org/poky
     $ cd poky
     $ git checkout -b fido origin/fido
            

You need some packages for everything to work. Rather than duplicate them here, look at the "The Packages" section earlier in this quick start.

From the root directory of your Source Directory, initialize your environment and provide a meaningful Build Directory name:

     $ source oe-init-build-env mybuilds
            

At this point, the mybuilds directory has been created for you and it is now your current working directory. If you do not provide your own directory name, it defaults to build, which is inside the Source Directory.

Initializing the build environment creates a conf/local.conf configuration file in the Build Directory. You need to manually edit this file to specify the machine you are building:

     MACHINE ?= "beaglebone"
            

A good deal that goes into a Yocto Project build is simply downloading all of the source tarballs. Steps exist that can help you be more efficient with gathering source files. For example, you can set up local mirrors that hold your source tarballs or you can pre-fetch all your source without initiating a build until later. For more information, see the "Working with Source Files" section in the Yocto Project Development Manual.

At this point, you need to select an image to build for the Beaglebone hardware. If this is your first build using the Yocto Project, you should try the smallest and simplest image:

     $ bitbake core-image-minimal
            

Now you just wait for the build to finish.

By default, BitBake aborts when it encounters an error during the build. If you want to make sure the build continues even when BitBake encounters an error, use this variation:

     $ bitbake -k core-image-minimal
            

Once you have your image, you can take steps to load and boot it on the target hardware.

You can learn about BitBake in general by reading the BitBake User Manual.