Skip to content

chore: update Ubuntu 24.04 build environment script and docs #7211

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
pfeerick merged 9 commits into from
Mar 27, 2026
Merged

chore: update Ubuntu 24.04 build environment script and docs #7211

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
b70ce56
tools: update Ubuntu 22.04 build environment script to match CI Docke…
pfeerick Mar 23, 2026
9df117f
fix: aqt installation location changed
pfeerick Mar 23, 2026
c576c10
tools: extract Qt and ARM toolchain versions as top-level constants
pfeerick Mar 23, 2026
6b125cd
tools: add Qt bin directory to PATH and improve quoting
pfeerick Mar 23, 2026
ee5de80
tools: create /opt/qt and set ownership before Qt installation
pfeerick Mar 23, 2026
9c1883a
docs: update Ubuntu 22.04 build instructions to reflect current tooling
pfeerick Mar 24, 2026
e48eeed
chore: update Ubuntu 24.04 build environment script and docs
pfeerick Mar 24, 2026
416e205
docs: reference compilation-options.md from Ubuntu build guides
pfeerick Mar 24, 2026
2149657
fix: avoid pip uninstall failure for apt-managed packages on Ubuntu 2…
pfeerick Mar 27, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
96 changes: 63 additions & 33 deletions docs/building/linux-ubuntu-22.04.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,7 @@
# Build Instructions under Ubuntu 22.04

Last tested with Ubuntu 22.04.5 LTS in March 2026.

The document here is meant to help you develop or test changes to EdgeTX on your PC, not to build flight/radio safe version of binaries.

- [Setting up the build environment for EdgeTX](#setting-up-the-build-environment-for-edgetx)
Expand All @@ -8,7 +10,7 @@ The document here is meant to help you develop or test changes to EdgeTX on your

## Setting up the build environment for EdgeTX

You can setup Ubuntu 22.04 on bare-metal, inside a virtual machine environment, or using WSL2 under Windows 10. For WSL2 installation, please see a dedicated page about it: [Setting up Ubuntu 20.04 in a Windows Subsystem for Linux](linux-wsl.md).
You can setup Ubuntu 22.04 on bare-metal, inside a virtual machine environment, or using WSL2 under Windows 10/11. For WSL2 installation, please see a dedicated page about it: [Setting up Ubuntu in a Windows Subsystem for Linux](linux-wsl.md).

* Download [Ubuntu 22.04](https://ubuntu.com/download/desktop) and install it (using Minimal installation type is sufficient. Allow _Download updates while installing Ubuntu_. 3rd party software is not required, unless you need this for graphics or WiFi adapter on your PC).
* When the installer has finished and the obligatory reboot is done, log in. Install updates using Software Updater (click _Activities_ in top left corner, type in _Software Updater_ and press _Enter_). **Restart** the PC and log in again after reboot.
Expand All @@ -17,12 +19,12 @@ You can setup Ubuntu 22.04 on bare-metal, inside a virtual machine environment,
wget https://raw.githubusercontent.com/EdgeTX/edgetx/main/tools/setup_buildenv_ubuntu22.04.sh
```
```
chmod a+x setup_buildenv_ubuntu22.04.sh
chmod +x setup_buildenv_ubuntu22.04.sh
```
```
./setup_buildenv_ubuntu22.04.sh
```
* If all went smoothly, you should not have seen any errors.
* If all went smoothly, you should not have seen any errors, and should have been informed that setup was finished.

If you are interested to see what the script does or which functions it calls, you can open it in a text editor and have look at it - it's pretty self-explanatory (_gedit_ for example in Ubuntu is a text editor with syntax highlighting). You can alternatively start the script with _--pause_ argument to stop the script execution after each step to better inspect the output. To achieve this, issue `./setup_buildenv_ubuntu22.04.sh --pause` as the last command in the above list instead.

Expand All @@ -43,43 +45,45 @@ We will next fetch the EdgeTX source files from the GitHub main development bran
git clone --recursive -b main https://github.com/EdgeTX/edgetx.git edgetx_main
```
```
cd edgetx_main && mkdir build-output && cd build-output
cd edgetx_main && mkdir build-output
```

To build EdgeTX, we need to minimally specify the radio target, but can further select or de-select a number of build-time options. The following command will create a text-file list of all options for you to look at and saves it in current user home directory:
To build EdgeTX, we need to minimally specify the radio target, but can further select or de-select a number of build-time options. A full list of available options is documented on the [Compilation Options](compilation-options.md) page. You can also generate a text-file list of all options by running:
```
cmake -LAH ../ > ~/edgetx_main-cmake-options.txt
cmake -LAH -S . > ~/edgetx_main-cmake-options.txt
```

You can use, e.g. _gedit_ under Ubuntu to view the file.

As an example, we will build next for RadioMaster TX16S (PCB=X10, PCBREV=TX16S), mode 2 default stick (DEFAULT_MODE=2), global variables enabled (GVARS=YES), servo output unit as microseconds (PPM_UNIT=US), include Lua mixer script support (LUA_MIXER=YES) and selected the type as a Debug build with debug symbols included (CMAKE_BUILD_TYPE=Debug). The CMake command for this is (issue the following without line breaks and be sure to include at the end the two dots and a slash exactly as here listed):
As an example, we will build next for RadioMaster TX16S (PCB=X10, PCBREV=TX16S), mode 2 default stick (DEFAULT_MODE=2, will otherwise default to mode 1) and selected the type as a Debug build with debug symbols included (CMAKE_BUILD_TYPE=Debug). The CMake command for this is:
```
cmake -DPCB=X10 -DPCBREV=TX16S -DDEFAULT_MODE=2 -DGVARS=YES -DPPM_UNIT=US -DLUA_MIXER=YES -DCMAKE_BUILD_TYPE=Debug ../
cmake --fresh -S . -B build-output -Wno-dev -DPCB=X10 -DPCBREV=TX16S -DDEFAULT_MODE=2 -DCMAKE_BUILD_TYPE=Debug
```
If you do not want to include the debug symbols, use `-DCMAKE_BUILD_TYPE=Release` instead.

To build for other radios, you just need to select another build target by specifying appropriate values for `PCB` and `PCBREV` for your radio. If you are are wanting to build for multiple different targets, it is best to use a different build folder for each. Otherwise, delete the `CMakeCache.txt` file from the build directory before before running `cmake` to configure a different transmitter build, otherwise cached configuration values from your previous build target will cause weird compile results. As a tip, which values to use, have a look at a Python script according to your radio manufacturer in a file named `build-<radio-manufacturer>.py` under [https://github.com/EdgeTX/edgetx/tree/main/tools](https://github.com/EdgeTX/edgetx/tree/main/tools)
To build for other radios, you just need to select another build target by specifying appropriate values for `PCB` and `PCBREV` for your radio. It is best to use a different build folder for each target. As a tip for which values to use, have a look at a Python script according to your radio manufacturer in a file named `build-<radio-manufacturer>.py` under [https://github.com/EdgeTX/edgetx/tree/main/tools](https://github.com/EdgeTX/edgetx/tree/main/tools)

Starting with 2.8, an additional step is required. Issue:
It is recommended to set the `CMAKE_BUILD_PARALLEL_LEVEL` environment variable to the number of CPU cores on your system, to speed up all subsequent builds:
```
make configure
export CMAKE_BUILD_PARALLEL_LEVEL=$(nproc)
```
Alternatively, you can issue `make arm-none-eabi-configure` if you only want to build radio firmware or `make native-configure` if you only want to build targets meant to be run on computer (running `make configure` activates both architecture targets).

Only a few seconds later, you should be greeted with "-- Generating done" message.
To configure, issue:
```
cmake --build build-output --target arm-none-eabi-configure
```

The configure process generates the _makefile_ that is required in the next step to build the firmware. For this, issue:
To build the firmware, issue:
```
make -j`nproc` firmware
cmake --build build-output --target firmware --parallel
```
This process can take some minutes to complete (the parameter -j'nproc' instructs the make to use as many parallel threads as the current system has CPU cores. This speeds up the build quite significantly).
If successful, you should find a firmware binary _firmware.bin_ in the current folder, that you can flash into your radio.

It's a good idea to rename the binary, so that it is easier later to see the target radio and which options were baked into it. For this, issue in the build folder, e.g.:
This process can take some minutes to complete.
If successful, you should find a firmware binary _firmware.bin_ in the `build-output/arm-none-eabi` folder, that you can flash onto your radio.

It's a good idea to rename the binary, so that it is easier later to see the target radio and which options were baked into it. For this, issue e.g.:
```
cd arm-none-eabi
mv firmware.bin edgetx_main_tx16s_lua-ppmus-mode2_debug.bin
mv build-output/arm-none-eabi/firmware.bin edgetx_main_tx16s_mode2_debug.bin
```

You will need to prepare a clean microSD card and fill it with the content according to your radio type from [https://github.com/EdgeTX/edgetx-sdcard/releases/tag/latest](https://github.com/EdgeTX/edgetx-sdcard/releases/tag/latest)
Expand All @@ -91,31 +95,57 @@ You can use [EdgeTX Buddy](https://buddy.edgetx.org/), [EdgeTX Companion](https:

## Building Companion, Simulator and radio simulator libraries

To build radio simulator library, issue in the same terminal as opened previously:
### After EdgeTX 2.12

You can build firmware, the radio simulator module, Companion and Simulator all in one step:
```
make -j`nproc` libsimulator
cmake --build build-output --parallel --target firmware --target wasi-module --target companion --target simulator
```

From EdgeTX 2.10 onwards, Companion and Simulator only incorporate hardware definitions for radio simulated libraries built before they themselves are built.
This will configure and download extra dependencies as needed. Alternately, if you only want to build the simulator module at this point, you can run

In order to build for other radio target, you need to re-run the `cmake` line above, with other `PCB` and `PCBREV` tags.
```
cmake --build build-output --parallel --target wasi-module
```

The wasm simulator module is built into `build-output/wasm/wasm-build/` but Companion looks for it in `build-output/native/`. Copy it across before launching Companion or Simulator:
```
cp build-output/wasm/wasm-build/*.wasm build-output/native/
```

After building all required radio simulator libraries, build the EdgeTX Companion binary, issue in the same terminal as opened previously:
If you want to build simulator modules for multiple radio targets (so they are all available in Companion), the helper script `tools/build-wasm-modules.sh` can build all supported targets in one go:
```
make -j`nproc` companion
tools/build-wasm-modules.sh . ./wasm-modules/
```
To launch Companion, change into `native` directory and issue: `./companion<ver>`
where `<ver>` is EdgeTX version string in format of two digits. For example, for EdgeTX 2.9 use 29, thus `companion29`, for 2.10 `companion210` and so on.
The `.wasm` files are output to `./wasm-modules/`. Copy them to `build-output/native/` before building Companion.

To build EdgeTX Simulator binary, issue:
Change into the `native` directory, where `<ver>` is the EdgeTX version as digits (e.g. `212` for 2.12):
```
make -j`nproc` simulator
cd build-output/native
```

Before you run the simulator, copy the SD card content according to your radio target from [https://github.com/EdgeTX/edgetx-sdcard/releases/tag/latest](https://github.com/EdgeTX/edgetx-sdcard/releases/tag/latest) to your system and extract it e.g. to `~/edgetx/simu_sdcard/horus`
To launch Companion:
```
./companion<ver>
```

Also, you should create a radio profile first with `./companion<ver>`, before you can successfully run the full simulator.
Before running the simulator, copy the SD card content for your radio target from [https://github.com/EdgeTX/edgetx-sdcard/releases/tag/latest](https://github.com/EdgeTX/edgetx-sdcard/releases/tag/latest) and extract it e.g. to `~/edgetx/simu_sdcard/horus`. You should also create a radio profile first in Companion before running the simulator.

To launch the simulator, change into `native` directory and issue: `./simulator<ver>`. In the dialog that pops up, select _SD Path_ as data source and under _SD Image Path:_ browse to `~/edgetx/simu_sdcard/horus`
To launch the simulator:
```
./simulator<ver>
```
In the dialog that pops up, select _SD Path_ as data source and under _SD Image Path:_ browse to `~/edgetx/simu_sdcard/horus`

[![EdgeTX simulator on Linux](../assets/images/build/linux/EdgeTX_simulator_Linux.png)](../assets/images/build/linux/EdgeTX_simulator_Linux.png)

### Legacy: EdgeTX 2.10 to 2.12

From 2.10 onwards, Companion and Simulator only incorporate hardware definitions for radio simulator libraries built before they themselves are built. You need to build a `libsimulator` for each radio target you want to include.

To include additional radio targets, re-run the `cmake --fresh` configure command from above with different `PCB` and `PCBREV` values, then build `libsimulator` again for each **before** building Companion.

Build the radio simulator library for your target, then Companion and Simulator:
```
cmake --build build-output --parallel --target libsimulator --target companion --target simulator
```
Loading