General Development Notes

Red Panda C++ need Qt 5.15 to build.

Recommended development environments:

1. Visual Studio Code.
   • Better performance.
2. Qt Creator.
   • (Almost) zero configuration.
   • Built-in UI designer.
   • Debugger integration with Qt.

To setup development environment in Visual Studio Code: 0. (Windows only) Enable Developer Mode in Windows Settings, and enable core.symlinks in Git (git config core.symlinks true).

1. Install xmake and XMake extension.
2. Install C/C++ extension for language and debugging support.
3. Optionally install clangd and clangd extension for better analysis.
4. Config workspace:
   • Compile commands: .vscode/compile_commands.json (“C/C++: Edit Configurations (UI)” from the Command Palette);
   • “Clangd: Arguments”: --compile-commands-dir=.vscode;
   • “Xmake: Additional Config Arguments”: --qt=/usr for example.
5. Run “XMake: UpdateIntellisense” (Command Palette) to generate compilation database.

* Note: xmake was introduced for compilation database generation and feature matrix test. It is not fully functional yet.

Windows

See also more build instructions for Windows.

MSYS2 Qt Library with MinGW Toolchain (Recommended)

Red Panda C++ should work with any MinGW toolchain from MSYS2, including GCCs and Clangs in three GNU-based environments (MINGW32, MINGW64 and UCRT64), and Clangs in three LLVM-based environments (CLANG32, CLANG64 and CLANGARM64; see also MSYS2’s document), while the following toolchains are frequently tested:

• MINGW32 GCC,
• MINGW64 GCC,
• UCRT64 GCC (recommended for x64)
• CLANGARM64 Clang (the only and recommended toolchain for ARM64).

Official distributions of Red Panda C++ are built with MINGW32 GCC and MINGW64 GCC.

Prerequisites:

0. Windows 10 x64 or later, or Windows 11 ARM64.
1. Install MSYS2.
2. In selected environment, install toolchain, Qt 5 library, and required utils:

   pacman -S \
     $MINGW_PACKAGE_PREFIX-{toolchain,qt5-static,7zip,cmake} \
     mingw-w64-i686-nsis \
     git curl

To build, launch selected MSYS2 environment, run:

./packages/msys/build-mingw.sh

to build Red Panda C++ installer and portable package with MinGW GCC toolchain or without compiler; and

./packages/msys/build-llvm.sh

to build Red Panda C++ installer with LLVM MinGW toolchain.

Common arguments:

• -h, --help: show help message.
• -c, --clean: clean build directory.
• -nd, --no-deps: do not check dependencies.
• -t <dir>, --target-dir <dir>: set target directory for the packages. Default: dist/.

Extra arguments for build-mingw.sh:

• --mingw32: add assets/mingw32.7z to the package.
• --mingw64: add assets/mingw64.7z to the package.
• --mingw: alias for --mingw32 (x86 app) or --mingw64 (x64 app).
• --ucrt <build>: add UCRT runtime from Windows SDK to the package. e.g. --ucrt 22621 for Windows 11 SDK 22H2.

Windows NT 5.x Qt Library with MinGW Lite Toolchain

The script build-xp.sh is alike build-mingw.sh, but the toolchain is provided by Qt library.

Prerequisites:

0. Windows 10 x64 or later.
1. Install MSYS2.
2. Install required utils:

   pacman -S \
     mingw-w64-x86_64-{7zip,cmake} \
     mingw-w64-i686-nsis \
     git curl
3. Download Windows XP Qt Library and extract to C:/Qt.
   • The directory structure should be like

     C:
     └─ Qt
        └─ 5.15.13+redpanda1
           ├─ mingw141_32-msvcrt
           │  ├─ bin
           │  │  ├─ gcc.exe
           │  │  ├─ mingw32-make.exe
           │  │  └─ qmake.exe
           │  ├─ include
           │  ├─ lib
           │  └─ ...
           └─ mingw141_64-msvcrt
              ├─ bin
              │  ├─ gcc.exe
              │  ├─ mingw32-make.exe
              │  └─ qmake.exe
              ├─ include
              ├─ lib
              └─ ...
   • Or you can build from source and specify the path with --qt argument.

To build, launch MSYS2 environment, run:

./packages/msys/build-xp.sh -p 32-msvcrt

This script accepts the same arguments as build-mingw.sh, plus:

• -p|--profile <profile>: (REQUIRED) the profile of MinGW Lite as well as Qt library. Available profiles are 64-ucrt, 64-msvcrt, 32-ucrt, 32-msvcrt, 32-win2000.

• --qt <dir>: set Qt directory. e.g. --qt /d/myqt-32.

  The directory structure should be like

  D:
  └─ myqt-32
     ├─ bin
     ├─ include
     ├─ lib
     └─ ...

Linux

See also more build instructions for freedesktop.org-conforming (XDG) desktop systems.

Alpine Linux, Arch Linux, Debian and Its Derivatives, Fedora, openSUSE

1. Setup build environment (documentation for Alpine, Arch, Debians, RPM).
   • For Debians:

     sudo apt install --no-install-recommends build-essential debhelper devscripts equivs
2. Call build script:
   • Alpine Linux: ./packages/alpine/buildapk.sh
   • Arch Linux: ./packages/archlinux/buildpkg.sh
   • Debians: ./packages/debian/builddeb.sh
   • Fedora: ./packages/fedora/buildrpm.sh
   • openSUSE: ./packages/opensuse/buildrpm.sh
3. Install the package:
   • Alpine Linux: ~/packages/unsupported/$(uname -m)/redpanda-cpp-git-*.apk
   • Arch Linux: /tmp/redpanda-cpp-git/redpanda-cpp-git-*.pkg.tar.zst
   • Debians: /tmp/redpanda-cpp_*.deb
   • Fedora, openSUSE: ~/rpmbuild/RPMS/$(uname -m)/redpanda-cpp-git-*.rpm
4. Run Red Panda C++:

   RedPandaIDE

Note that some of these scripts check out HEAD of the repo, so any changes should be committed before building.

Alternatively, build in container (rootless Podman preferred; Docker may break file permissions):

podman run --rm -v $PWD:/mnt -w /mnt <image> ./packages/<distro>/01-in-docker.sh

# Arch Linux for example
podman run --rm -v $PWD:/mnt -w /mnt docker.io/archlinux:latest ./packages/archlinux/01-in-docker.sh

The package will be placed in dist/.

Statically Linked Binary for Ubuntu 20.04 x86_64 (NOI Linux 2.0)

The package redpanda-cpp-bin is roughly “AppImage repack”. The binary is actually built in a container. Thus the build host is not necessarily Ubuntu 20.04; any Linux distribution with Podman and dpkg should work.

1. Install Podman, and dpkg if build host is not Debian or its derivatives:

   sudo apt install podman
   WARNING: DO NOT install packages with dpkg on non-Debians, or your system will be terminated.
2. Call build script:

   ./packages/debian-static/builddeb.sh

The package will be placed in dist/.

Linux AppImage

podman run --rm -v $PWD:/mnt -w /mnt quay.io/redpanda-cpp/appimage-builder-x86_64:20240304.0 ./packages/appimage/01-in-docker.sh

Dockerfiles are available in redpanda-cpp/appimage-builder. Available architectures: x86_64, aarch64, riscv64.

macOS

Qt.io Qt Library

Prerequisites:

0. macOS 10.13 or later.
1. Install Xcode Command Line Tools:

   xcode-select --install
2. Install Qt with online installer from Qt.io.
   • Select the library (in Qt group, Qt 5.15.2 subgroup, check macOS).

Build:

1. Set related variables:

   SRC_DIR="~/redpanda-src"
   BUILD_DIR="~/redpanda-build"
   INSTALL_DIR="~/redpanda-pkg"
2. Navigate to build directory:

   rm -rf "$BUILD_DIR" # optional for clean build
   mkdir -p "$BUILD_DIR" && cd "$BUILD_DIR"
3. Configure, build and install:

   ~/Qt/5.15.2/clang_64/bin/qmake PREFIX="$INSTALL_DIR" "$SRC_DIR/Red_Panda_CPP.pro"
   make -j$(sysctl -n hw.logicalcpu)
   make install
   ~/Qt/5.15.2/clang_64/bin/macdeployqt "$INSTALL_DIR/bin/RedPandaIDE.app"