Linux Cross Development


Developing software for embedded devices has many challenges. One of them is to be able to build software for different platforms than the ones used by the developers. It is necessary to have a clear set of dependencies and reduce the overhead of optional libraries.

In this post, I will present briefly how Ubuntu 20.04 can cross-compile a C++ executable or use Docker to have a container running Arm64 on an Amd64 machine to build a package for Ubuntu 20.04.


Photo by Ketut Subiyanto from Pexels


Cross-compile allows a developer to create an application for a different computer architecture than the one used for development and to have enough resources not only to run, but also to benchmark and debug the software faster.

“To cross-compile is to build on one platform a binary that will run on another platform”[1]


Today there are different tools that help with cross-compilation, to name a few:

  • The Yocto project that can generate not only binaries but, complete Linux distributions[2]
  • Crosstool-NG that help’s to build only toolchains[3]
  • Docker together with Qemu could help build the binaries for arm64 and amd64 machines.
  • Cross-tool packages from a Linux distribution.

On this post we focus only on the last two that works for us developing for Raspberry Pi’s.

Run a Docker Arm64 container on a Amd64 machine

This alternative is quite simple to run and is very well supported by debian distributions.

  • Using ubuntu 20.04 try the following command

    docker run arm64v8/ubuntu

    See that we have to prepend the architecture arm64v8:

  • You should see the message:

    WARNING: The requested image's platform (linux/arm64/v8) does not match the detected host platform (linux/amd64) and no specific platform was requested
  • Install the library on ubuntu sudo apt install qemu-user-static and run the command:

    docker run --platform linux/arm64 arm64v8/ubuntu uname -m
  • You should see the output:


Congratulations, now you are running ubuntu on an amd64 system, you can also build images with docker build. It can be not as efficient as runing directly on the machine, but will allow you to build and run packages for Arm64 or 32 without much more effort.

Using the cross-tool packages for GCC

Another option is to build using GCC, this will work for a program without dependencies but will make it very difficult to have all the dependencies for the right architecture.

  • Dependencies

    sudo apt install build-essential autoconf libtool cmake pkg-config git
  • Install the libraries for cross-compilation

    sudo apt install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu g++-arm-linux-gnueabihf
  • Prepare the CMAKE file with the following dependencies

    cmake_minimum_required(VERSION 3.1)
    set(CMAKE_SYSTEM_NAME Linux)
    SET(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
    SET(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
    add_executable(${PROJECT_NAME} main.cpp)
  • The C++ code that will be executed

    #include <iostream>
    int main() {
        std::cout << "Cross compiled" << std::endl;
        return 0;
  • Build

    mkdir build && cd build && cmake .. && make
  • Check the architecture for the binary with file test the output will be test: ELF 64-bit LSB shared object, ARM aarch64 ...

  • Run the binary on an arm64 machine

    docker run -it --rm --platform linux/arm64 -v $PWD:/test arm64v8/ubuntu /test/test

Congrats you should see: Cross compiled on the standard out.

Having a program today that runs on different processor architectures is a given. For example, Java or Python allows developers to run applications almost transparently on different computer architectures. Still, the capability of doing so on systems with low resources is higly beneficial to be able to test first and then cross-compile on the target device.