TinyComputers.io (Posts about arm64)

Building Cross-Platform Rust Binaries: A Multi-Architecture Build Orchestration System

A.C. Jokela — Fri, 21 Nov 2025 21:19:35 GMT

When developing ballistics-engine, a high-performance ballistics calculation library written in Rust, I faced a challenge: how do I efficiently build and distribute binaries for multiple operating systems and architectures? The answer led to the creation of an automated build orchestration system that leverages diverse hardware—from single-board computers to powerful x86_64 servers—to build native binaries for macOS, Linux, FreeBSD, NetBSD, and OpenBSD across both ARM64 and x86_64 architectures. Now, you are probably wondering why I am bothering to show love for the BSD Trilogy; the answer is simple: because I want to. Sure they are a bit esoteric, but I ran FreeBSD for years as my mail server. I still like the BSDs.

This article explores the architecture, implementation, and lessons learned from building a production-grade multi-platform build system that powers https://ballistics.zip, where users can download pre-built binaries for their platform with a simple curl command.

curl --proto '=https' --tlsv1.2 -sSf https://ballistics.zip/install.sh | sh

The Problem: Cross-Platform Distribution

Rust's cross-compilation capabilities are impressive, but they have limitations:

Cross-compilation complexity: While Rust supports cross-compilation, getting it working reliably for BSD systems (especially with system dependencies) is challenging
Native testing: You need to test on actual hardware to ensure binaries work correctly
Binary compatibility: Different BSD versions and configurations require native builds
Performance verification: Emulated builds may behave differently than native ones

The solution? Build natively on each target platform using actual hardware or high-performance emulation.

Architecture Overview

The build orchestration system consists of three main components:

1. Build Nodes (Physical and Virtual Machines)

macOS systems (x86_64 and aarch64) - Local builds
Linux x86_64 server - Remote build via SSH
FreeBSD ARM64 - Single-board computer (Raspberry Pi 4)
OpenBSD ARM64 - QEMU VM emulated on x86_64 (rig.localnet)
NetBSD x86_64 and ARM64 - QEMU VMs

2. Orchestrator (Python-based coordinator)

Reads build node configuration from build-nodes.yaml
Executes builds in parallel across all nodes
Collects artifacts via SSH/SCP
Generates SHA256 checksums
Uploads to Google Cloud Storage
Updates version metadata

3. Distribution (ballistics.zip website)

Serves install script at https://ballistics.zip
Hosts binaries in GCS bucket (gs://ballistics-releases/)
Provides version detection and automatic downloads
Supports version fallback for platforms with delayed releases

Hardware Infrastructure

Single-Board Computers

Orange Pi 5 Max (ARM64)

Role: Host for NetBSD ARM64 VM
CPU: Rockchip RK3588 (8-core ARM Cortex-A76/A55)
RAM: 16GB
Why: Native ARM64 hardware for running QEMU VMs
Host IP: 10.1.1.10
VM IPs:
NetBSD ARM64: 10.1.1.15
OpenBSD ARM64 (native, disabled): 10.1.1.11

Raspberry Pi 4 (ARM64)

Role: FreeBSD ARM64 native builds
CPU: Broadcom BCM2711 (quad-core Cortex-A72)
RAM: 8GB
Why: Stable FreeBSD support, reliable ARM64 platform
IP: 10.1.1.7

x86_64 ("rig.localnet")

Role: Linux builds, BSD VM host, emulated ARM64 builds
CPU: Intel i9
RAM: 96GB
IP: 10.1.1.27 (Linux host), 10.1.1.17 (KVM host)
VMs Hosted:
FreeBSD x86_64: 10.1.1.21
OpenBSD x86_64: 10.1.1.20
OpenBSD ARM64 (emulated): 10.1.1.23
NetBSD x86_64: 10.1.1.19

Local macOS Development Machine

Role: macOS binary builds (both architectures)
Build Method: Local cargo builds with target flags
Architectures:
aarch64-apple-darwin (Apple Silicon)
x86_64-apple-darwin (Intel Macs)

A Surprising Discovery: Emulated ARM64 Performance

One of the most interesting findings during development was discovering that emulated ARM64 builds on powerful x86_64 hardware are significantly faster than emulated ARM64 on native ARM64 builds on single-board computers.

Performance Comparison

Emulated ARM64 on ARM64: ~99+ minutes per build
Emulated ARM64 on x86_64: 15m 37s ⚡

The emulated build on rig.localnet (running QEMU with KVM acceleration) completed in about 6x less time than the native ARM64 hardware. This is because:

The x86_64 server has significantly more powerful CPU cores
QEMU with KVM provides near-native performance for many workloads
Rust compilation is primarily CPU-bound and benefits from faster single-core performance
The x86_64 server has faster storage (NVMe vs eMMC/SD card)

As a result, the native OpenBSD ARM64 node on the Orange Pi is now disabled in favor of the emulated version.

Prerequisites

SSH Key-Based Authentication

Critical: The orchestration system requires passwordless SSH access to all remote build nodes. Here's how to set it up:

Generate SSH key (if you don't have one):

ssh-keygen -t ed25519 -C "build-orchestrator"

Copy public key to each build node:

# For each build node
ssh-copy-id user@build-node-ip

# Examples:
ssh-copy-id alex@10.1.1.27      # Linux x86_64
ssh-copy-id freebsd@10.1.1.7     # FreeBSD ARM64
ssh-copy-id root@10.1.1.20       # OpenBSD x86_64
ssh-copy-id root@10.1.1.23       # OpenBSD ARM64 emulated
ssh-copy-id root@10.1.1.19       # NetBSD x86_64
ssh-copy-id root@10.1.1.15       # NetBSD ARM64

Test SSH access:

ssh user@build-node-ip "uname -a"

Software Requirements

On Build Orchestrator Machine:

Python 3.8+
pyyaml (pip install pyyaml)
Google Cloud SDK (gcloud command) for GCS uploads
SSH client

On Each Build Node:

Rust toolchain (cargo, rustc)
Build essentials (compiler, linker)
curl, wget, or ftp (for downloading source)
Sufficient disk space (~2GB for build artifacts)

BSD-Specific Requirements

NetBSD: Install curl via pkgsrc (native ftp doesn't support HTTPS)

# Bootstrap pkgsrc
cd /usr && ftp -o pkgsrc.tar.gz http://cdn.netbsd.org/pub/pkgsrc/current/pkgsrc.tar.gz
tar -xzf pkgsrc.tar.gz
cd /usr/pkgsrc/bootstrap && ./bootstrap --prefix=/usr/pkg

# Install curl
/usr/pkg/bin/pkgin -y update
/usr/pkg/bin/pkgin -y install curl

OpenBSD: Native ftp supports HTTPS

pkg_add rust git

FreeBSD: Use pkg for everything

pkg install -y rust git curl

The ballistics.zip Website and Install Script

How It Works

https://ballistics.zip serves as the primary distribution point for pre-built ballistics-engine binaries. The system uses:

GCS Bucket:
gs://ballistics-releases/ - Binary artifacts
CDN: Google Cloud CDN provides global distribution
Install Script: Universal installer that:
Detects OS and architecture
Downloads appropriate binary
Verifies SHA256 checksum
Installs to /usr/local/bin

Usage

Basic installation:

curl -sSL https://ballistics.zip/install.sh | bash

Specific version:

curl -sSL https://ballistics.zip/install.sh | bash -s -- --version 0.13.3

Different install location:

curl -sSL https://ballistics.zip/install.sh | bash -s -- --prefix ~/.local

Install Script Architecture

The install.sh script intelligently handles:

Platform Detection:

OS=$(uname -s | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m)

case "$ARCH" in
  x86_64|amd64) ARCH="x86_64" ;;
  aarch64|arm64) ARCH="aarch64" ;;
  *) echo "Unsupported architecture: $ARCH"; exit 1 ;;
esac

PLATFORM="${OS}-${ARCH}"  # e.g., "openbsd-aarch64"

Version Fallback: If a requested version isn't available for a platform, the script automatically finds the latest available version:

# If openbsd-aarch64 0.13.3 doesn't exist, fall back to 0.13.2
AVAILABLE_VERSION=$(curl -sL $BASE_URL/versions.txt | grep "^$PLATFORM:" | cut -d: -f2)

Checksum Verification:

EXPECTED_SHA=$(cat "$BINARY.sha256")
ACTUAL_SHA=$(sha256sum "$BINARY" | awk '{print $1}')

if [ "$EXPECTED_SHA" != "$ACTUAL_SHA" ]; then
  echo "Checksum verification failed!"
  exit 1
fi

Build Orchestration System Deep Dive

Configuration: build-nodes.yaml

The heart of the system is build-nodes.yaml, which defines all build targets:

nodes:
  # macOS builds (local machine)
  - name: macos-aarch64
    host: local
    target: aarch64-apple-darwin
    build_command: |
      cd /tmp && rm -rf ballistics-engine-{version}
      curl -L -o v{version}.tar.gz https://github.com/ajokela/ballistics-engine/archive/refs/tags/v{version}.tar.gz
      tar xzf v{version}.tar.gz
      cd ballistics-engine-{version}
      cargo build --release --target {target}
    binary_path: /tmp/ballistics-engine-{version}/target/{target}/release/ballistics
    enabled: true

  # Linux x86_64 (remote via SSH)
  - name: linux-x86_64
    host: alex@10.1.1.27
    target: x86_64-unknown-linux-gnu
    build_command: |
      cd /tmp && rm -rf ballistics-engine-{version}
      wget -q https://github.com/ajokela/ballistics-engine/archive/refs/tags/v{version}.tar.gz
      tar xzf v{version}.tar.gz
      cd ballistics-engine-{version}
      ~/.cargo/bin/cargo build --release --target {target}
    binary_path: /tmp/ballistics-engine-{version}/target/{target}/release/ballistics
    enabled: true

  # OpenBSD ARM64 emulated (FASTEST ARM64 BUILD!)
  - name: openbsd-aarch64-emulated
    host: root@10.1.1.23
    target: aarch64-unknown-openbsd
    build_command: |
      cd /tmp && rm -rf ballistics-engine-{version}
      ftp -o v{version}.tar.gz https://github.com/ajokela/ballistics-engine/archive/refs/tags/v{version}.tar.gz
      tar xzf v{version}.tar.gz
      cd ballistics-engine-{version}
      cargo build --release
    binary_path: /tmp/ballistics-engine-{version}/target/release/ballistics
    enabled: true

  # NetBSD x86_64 (HTTPS support via pkgsrc curl)
  - name: netbsd-x86_64
    host: root@10.1.1.19
    target: x86_64-unknown-netbsd
    build_command: |
      cd /tmp && rm -rf ballistics-engine-{version}
      /usr/pkg/bin/curl -L -o v{version}.tar.gz https://github.com/ajokela/ballistics-engine/archive/refs/tags/v{version}.tar.gz
      tar xzf v{version}.tar.gz
      cd ballistics-engine-{version}
      /usr/pkg/bin/cargo build --release
    binary_path: /tmp/ballistics-engine-{version}/target/release/ballistics
    enabled: true

Orchestrator Workflow

The orchestrator.py script coordinates the entire build process:

Step 1: Parallel Build Execution

def build_on_node(node, version):
    if node['host'] == 'local':
        # Local build
        subprocess.run(build_command, shell=True, check=True)
    else:
        # Remote build via SSH
        ssh_command = f"ssh {node['host']} '{build_command}'"
        subprocess.run(ssh_command, shell=True, check=True)

Step 2: Artifact Collection

def collect_artifacts(node, version):
    binary_name = f"ballistics-{version}-{node['name']}"

    if node['host'] == 'local':
        shutil.copy(node['binary_path'], f"./{binary_name}")
    else:
        # Download via SCP
        scp_command = f"scp {node['host']}:{node['binary_path']} ./{binary_name}"
        subprocess.run(scp_command, shell=True, check=True)

Step 3: Checksum Generation

def generate_checksum(binary_path):
    with open(binary_path, 'rb') as f:
        sha256 = hashlib.sha256(f.read()).hexdigest()

    with open(f"{binary_path}.sha256", 'w') as f:
        f.write(sha256)

Step 4: Upload to GCS

def upload_to_gcs(version):
    bucket_path = f"gs://ballistics-releases/{version}/"

    # Upload binaries and checksums
    subprocess.run(f"gsutil -m cp ballistics-* {bucket_path}", shell=True)

    # Set public read permissions
    subprocess.run(f"gsutil -m acl ch -u AllUsers:R {bucket_path}*", shell=True)

    # Update latest-version.txt
    with open('latest-version.txt', 'w') as f:
        f.write(version)
    subprocess.run("gsutil cp latest-version.txt gs://ballistics-releases/", shell=True)

Running a Build

Dry-run (test without uploading):

cd build-orchestrator
./build.sh --version 0.13.4 --dry-run

Production build:

./build.sh --version 0.13.4

Output:

Building ballistics-engine v0.13.4
===========================================

Enabled build nodes: 7
- macos-aarch64 (local)
- macos-x86_64 (local)
- linux-x86_64 (alex@10.1.1.27)
- freebsd-aarch64 (freebsd@10.1.1.7)
- openbsd-aarch64-emulated (root@10.1.1.23)
- netbsd-x86_64 (root@10.1.1.19)
- netbsd-aarch64 (root@10.1.1.15)

Starting parallel builds...
[macos-aarch64] Building... (PID: 12345)
[linux-x86_64] Building... (PID: 12346)
...

Build results:
✓ macos-aarch64 (45s)
✓ linux-x86_64 (28s)
✓ freebsd-aarch64 (6m 32s)
✓ openbsd-aarch64-emulated (15m 37s)  ⚡ FASTEST ARM64!
...

Uploading to gs://ballistics-releases/0.13.4/
✓ Uploaded 7 binaries
✓ Uploaded 7 checksums
✓ Updated latest-version.txt

Build complete! 🎉
Total time: 16m 12s

Adding New Build Nodes

Interactive Script

The easiest way to add a new node is using the interactive script:

cd build-orchestrator
./add-node.sh

This will prompt you for: - Node name (e.g., openbsd-aarch64-emulated) - SSH host (e.g., root@10.1.1.23 or local) - Rust target triple (e.g., aarch64-unknown-openbsd) - Build commands (how to download and build) - Binary location (where the compiled binary is located)

Manual Configuration

Alternatively, edit build-nodes.yaml directly:

  - name: your-new-platform
    host: user@ip-address  # or 'local' for local builds
    target: rust-target-triple
    build_command: |
      # Commands to download source and build
      cd /tmp && rm -rf ballistics-engine-{version}
      curl -L -o v{version}.tar.gz https://github.com/...
      tar xzf v{version}.tar.gz
      cd ballistics-engine-{version}
      cargo build --release
    binary_path: /path/to/compiled/binary
    enabled: true

Variables: - {version}: Replaced with target version (e.g., 0.13.4) - {target}: Replaced with Rust target triple

Setting Up a New VM

Example: OpenBSD ARM64 Emulated

Create VM on host:

ssh alex@rig.localnet
cd /opt/bsd-vms/openbsd-arm64-emulated

Create boot script:

cat > boot.sh << 'EOF'
#!/bin/bash
exec qemu-system-aarch64 \
  -M virt,highmem=off \
  -cpu cortex-a57 \
  -smp 4 \
  -m 2G \
  -bios /usr/share/qemu-efi-aarch64/QEMU_EFI.fd \
  -drive file=openbsd.qcow2,if=virtio,format=qcow2 \
  -netdev bridge,id=net0,br=br0 \
  -device virtio-net-pci,netdev=net0,romfile=,mac=52:54:00:12:34:99 \
  -nographic
EOF
chmod +x boot.sh

Create systemd service:

sudo cat > /etc/systemd/system/openbsd-arm64-emulated-vm.service << 'EOF'
[Unit]
Description=OpenBSD ARM64 VM (Emulated on x86_64)
After=network.target

[Service]
Type=simple
User=alex
WorkingDirectory=/opt/bsd-vms/openbsd-arm64-emulated
ExecStart=/opt/bsd-vms/openbsd-arm64-emulated/boot.sh
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable openbsd-arm64-emulated-vm.service
sudo systemctl start openbsd-arm64-emulated-vm.service

Configure networking (assign static IP 10.1.1.23)
Install build tools inside VM:

ssh root@10.1.1.23
pkg_add rust git

Test SSH access:

ssh root@10.1.1.23 "cargo --version"

Add to build-nodes.yaml and test:

./build.sh --version 0.13.3 --dry-run

GitHub Webhook Integration (Optional)

For fully automated builds triggered by GitHub releases:

1. Deploy Webhook Receiver to Cloud Run

cd build-orchestrator
gcloud run deploy ballistics-build-webhook \
  --source . \
  --region us-central1 \
  --allow-unauthenticated \
  --set-env-vars GITHUB_WEBHOOK_SECRET=your-secret-here

2. Configure GitHub Webhook

Go to: https://github.com/yourusername/your-repo/settings/hooks
Add webhook:
Payload URL: https://ballistics-build-webhook-xxx.run.app/webhook
Content type: application/json
Secret: Your webhook secret
Events: Select "Releases" only

3. Test

Create a new release on GitHub, and the webhook will automatically trigger builds for all platforms!

Performance Metrics and Insights

From real-world builds of ballistics-engine v0.13.3:

Platform	Hardware	Build Time	Notes
macOS aarch64	Apple M1/M2	45s	Native Apple Silicon
macOS x86_64	Intel i7/i9	30s	Cross-compile on Apple Silicon
Linux x86_64	Xeon/EPYC	25s	Fastest overall ⚡
FreeBSD aarch64	Raspberry Pi 4	6m 32s	Native ARM64 hardware
OpenBSD aarch64 (emulated)	x86_64 QEMU	15m 37s	⚡ FASTEST ARM64
OpenBSD aarch64 (native)	Orange Pi 5 Max	99+ min	Disabled due to slower speed
NetBSD x86_64	x86_64 VM	3m 45s	KVM acceleration
NetBSD aarch64	Orange Pi VM	8m 12s	QEMU on ARM64 host

Key Insights:

x86_64 is fastest: Modern x86_64 CPUs dominate for single-threaded compilation
Emulation wins for ARM64: x86_64 emulating ARM64 beats native ARM64 SBCs
SBCs are viable: Raspberry Pi and Orange Pi work well for native builds, but slower
Parallel execution: Running all 7 builds in parallel takes only ~16 minutes (longest pole is FreeBSD ARM64)

Conclusion

Building a custom multi-platform build orchestration system may seem daunting, but the benefits are substantial:

→ Full control: Own your build infrastructure

→ Native builds: Real hardware ensures compatibility

→ Cost-effective: Low operational costs after initial hardware investment

→ Fast iteration: Parallel builds complete in ~16 minutes

→ Flexibility: Easy to add new platforms

→ Learning: Deep understanding of cross-platform development

The surprising discovery that emulated ARM64 on powerful x86_64 hardware outperforms native ARM64 single-board computers has practical implications: you don't always need native hardware for every architecture. Strategic use of emulation can provide better performance while maintaining compatibility.

For projects requiring broad platform support (especially BSD systems not well-served by traditional CI/CD), this approach offers a reliable, maintainable, and cost-effective solution.

Architecture Diagram

graph TB subgraph "Trigger Sources" GH[GitHub Release
v0.13.x] MANUAL[Manual Execution
./build.sh] end subgraph "Build Orchestrator" ORCH[Python Orchestrator
orchestrator.py] CONFIG[Build Configuration
build-nodes.yaml] end subgraph "Build Nodes - Local" MAC_ARM[macOS ARM64
Apple Silicon
~45s] MAC_X86[macOS x86_64
Rosetta 2
~30s] end subgraph "Build Nodes - Remote x86_64" LINUX_X86[Linux x86_64
alex@10.1.1.27
~25s] FREEBSD_X86[FreeBSD x86_64
root@10.1.1.21
~4m] OPENBSD_X86[OpenBSD x86_64
root@10.1.1.20
~12m] NETBSD_X86[NetBSD x86_64
root@10.1.1.19
~3m 45s] end subgraph "Build Nodes - Remote ARM64" FREEBSD_ARM[FreeBSD ARM64
freebsd@10.1.1.7
~6m 32s] OPENBSD_ARM_EMU[OpenBSD ARM64
root@10.1.1.23
Emulated on x86_64
~15m 37s ⚡] NETBSD_ARM[NetBSD ARM64
root@10.1.1.15
~8m 12s] end subgraph "Artifact Collection" COLLECT[SCP Collection
Pull binaries from nodes] CHECKSUM[Generate SHA256
checksums] end subgraph "Distribution" GCS[Google Cloud Storage
gs://ballistics-releases/] WEBSITE[ballistics.zip
Install Script] end GH -->|webhook| ORCH MANUAL -->|CLI| ORCH CONFIG -->|reads| ORCH ORCH -->|SSH parallel builds| MAC_ARM ORCH -->|SSH parallel builds| MAC_X86 ORCH -->|SSH parallel builds| LINUX_X86 ORCH -->|SSH parallel builds| FREEBSD_X86 ORCH -->|SSH parallel builds| OPENBSD_X86 ORCH -->|SSH parallel builds| NETBSD_X86 ORCH -->|SSH parallel builds| FREEBSD_ARM ORCH -->|SSH parallel builds| OPENBSD_ARM_EMU ORCH -->|SSH parallel builds| NETBSD_ARM MAC_ARM -->|binary| COLLECT MAC_X86 -->|binary| COLLECT LINUX_X86 -->|binary| COLLECT FREEBSD_X86 -->|binary| COLLECT OPENBSD_X86 -->|binary| COLLECT NETBSD_X86 -->|binary| COLLECT FREEBSD_ARM -->|binary| COLLECT OPENBSD_ARM_EMU -->|binary| COLLECT NETBSD_ARM -->|binary| COLLECT COLLECT --> CHECKSUM CHECKSUM --> GCS GCS --> WEBSITE style OPENBSD_ARM_EMU fill:#90EE90 style LINUX_X86 fill:#87CEEB style GCS fill:#FFD700 style WEBSITE fill:#FFD700

Diagram Legend

Green: Fastest ARM64 build (emulated on powerful x86_64)
Blue: Fastest overall build (native Linux x86_64)
Yellow: Distribution endpoints

Build Flow

Trigger: GitHub release webhook or manual execution
Parallel Execution: All enabled build nodes start simultaneously
Collection: Orchestrator collects binaries via SCP
Verification: SHA256 checksums generated for integrity
Upload: Binaries and checksums uploaded to GCS
Availability: Install script immediately serves new version

Rust Compilation Performance Benchmark Report

A.C. Jokela — Wed, 24 Sep 2025 11:47:53 GMT

Executive Summary

This report presents a comprehensive performance comparison of Rust compilation times across six different systems, including Single Board Computers (SBCs) and desktop systems. The benchmark reveals a 34x performance difference between the fastest and slowest systems, with the AMD AI Max+ 395 desktop processor demonstrating exceptional compilation performance.

Key Findings

Fastest System: Ubuntu x86_64 with AMD AI Max+ 395 - 13.71 seconds average
Slowest System: OpenBSD 7.7 - 470.67 seconds average
Best ARM Performance: Orange Pi 5 Max - 58.65 seconds average
Most Consistent: Ubuntu x86_64 with only 0.08s standard deviation

System Specifications

x86_64 Systems

System	OS	CPU	Cores	RAM	Architecture
Ubuntu Desktop	Ubuntu 24.04.3 LTS	AMD Ryzen AI Max+ 395	16	32GB + 96GB GPU VRAM	x86_64
OpenBSD VM	OpenBSD 7.7	Intel N100 (VirtualBox)	VM	1GB	x86_64

ARM64 Systems

System	OS	CPU	Cores	RAM	Architecture
Orange Pi 5 Max	Armbian 25.11	Cortex-A55/A76 (RK3588)	8 (4+4)	16GB	ARM64
Raspberry Pi CM5	Debian 12	Cortex-A76	4	8GB	ARM64
Banana Pi R2 Pro	Armbian 23.02	RK3568	4	2GB	ARM64
Pine64 Quartz64 B	Debian 12	RK3566	4	4GB	ARM64

System Information (neofetch)

Ubuntu Desktop (AMD Ryzen AI Max+ 395)

        .-/+oossssoo+/-.               alex@ubuntu-desktop
    `:+ssssssssssssssssss+:`           -------------------
  -+ssssssssssssssssssyyssss+-         OS: Ubuntu 24.04.3 LTS x86_64
.ossssssssssssssssssdMMMNysssso.       Kernel: 6.11.0
/ssssssssssshdmmNNmmyNMMMMhssssss/     Uptime: 2 days, 14 hours
+ssssssssshmydMMMMMMMNddddyssssssss+   Packages: 3127 (dpkg), 18 (snap)
/sssssssshNMMMyhhyyyyhmNMMMNhssssssss/ Shell: bash 5.2.21
.ssssssssdMMMNhsssssssssshNMMMdssssssss.Resolution: 3840x2160
+sssshhhyNMMNyssssssssssssyNMMMysssssss+DE: GNOME 46.0
ossyNMMMNyMMhsssssssssssssshmmmhssssssso WM: Mutter
ossyNMMMNyMMhsssssssssssssshmmmhssssssso CPU: AMD Ryzen AI MAX+ 395 (32) @ 5.100GHz
+sssshhhyNMMNyssssssssssssyNMMMysssssss+GPU: AMD Radeon 8060S
.ssssssssdMMMNhsssssssssshNMMMdssssssss.Memory: 8.7GiB / 30.5GiB (28%)
/sssssssshNMMMyhhyyyyhmNMMMNhssssssss/
+ssssssssshmydMMMMMMMNddddyssssssss+
/ssssssssssshdmmNNNmyNMMMMhssssss/
.ossssssssssssssssssdMMMNysssso.
  -+sssssssssssssssssyyyssss+-
    `:+ssssssssssssssssss+:`
        .-/+oossssoo+/-.

Orange Pi 5 Max

       _,met$$$$$gg.          root@orangepi5max
    ,g$$$$$$$$$$$$$$$P.       -----------------
  ,g$$P"     """Y$$.".        OS: Armbian (25.11) aarch64
 ,$$P'              `$$$.     Host: Orange Pi 5 Max
',$$P       ,ggs.     `$$b:   Kernel: 5.10.160-vendor-rk35xx
`d$$'     ,$P"'   .    $$$    Uptime: 3 days, 22 hours, 31 mins
 $$P      d$'     ,    $$P    Packages: 1742 (dpkg)
 $$:      $$.   -    ,d$$'    Shell: bash 5.1.16
 $$;      Y$b._   _,d$P'      Terminal: /dev/pts/0
 Y$$.    `.`"Y$$$$P"'         CPU: (8) @ 2.352GHz
 `$$b      "-.__              Memory: 2912MiB / 15733MiB
  `Y$$
   `Y$$.
     `$$b.
       `Y$$b.
          `"Y$b._
              `"""

Raspberry Pi Compute Module 5

  `.::///+:/-.        --/+//-:+:
 `+oooooooooooo:   `+oooooooooooo:    pi@raspberrypi
  /oooo++//ooooo:  ooooo+//+ooooo.    --------------
  `+ooooooo:-:oo-  +o+::/ooooooo:     OS: Debian GNU/Linux 12 (bookworm) aarch64
   `:oooooooo+``    `.oooooooo+-      Host: Raspberry Pi Compute Module 5 Rev 1.0
     `:++ooo/.        :+ooo+/.`       Kernel: 6.6.51+rpt-rpi-2712
        ...`  `.----.` ``..            Uptime: 1 day, 3 hours, 45 mins
     .::::-``:::::::::.`-:::-`         Packages: 1698 (dpkg)
    -:::-`   .:::::::-`  `-:::-        Shell: bash 5.2.15
   `::.  `.--.`  `` `.---.``.::`      Resolution: 1920x1080
       .::::::::`  -::::::::` `        Terminal: /dev/pts/0
 .::` .:::::::::- `::::::::::``::.    CPU: (4) @ 3.000GHz
-:::` ::::::::::.  ::::::::::.`:::-   Memory: 562MiB / 7928MiB
::::  -::::::::.   `-::::::::  ::::
-::-   .-:::-.``....``.-::-.   -::-
 .. ``       .::::::::.     `..`..
   -:::-`   -::::::::::`  .:::::`
   :::::::` -::::::::::` :::::::.
   .:::::::  -::::::::. ::::::::
    `-:::::`   ..--.`   ::::::.
      `...`  `...--..`  `...`
            .::::::::::
             `.-::::-`

Banana Pi R2 Pro

       _,met$$$$$gg.          root@bananapi-r2pro
    ,g$$$$$$$$$$$$$$$P.       -------------------
  ,g$$P"     """Y$$.".        OS: Armbian 23.02.2 Bullseye aarch64
 ,$$P'              `$$$.     Host: Bananapi BPI-R2PRO
',$$P       ,ggs.     `$$b:   Kernel: 5.19.17-rockchip64
`d$$'     ,$P"'   .    $$$    Uptime: 45 days, 18 hours, 22 mins
 $$P      d$'     ,    $$P    Packages: 1356 (dpkg)
 $$:      $$.   -    ,d$$'    Shell: bash 5.1.4
 $$;      Y$b._   _,d$P'      Terminal: /dev/pts/0
 Y$$.    `.`"Y$$$$P"'         CPU: Rockchip RK3568 (4) @ 1.960GHz
 `$$b      "-.__              Memory: 628MiB / 1924MiB
  `Y$$
   `Y$$.
     `$$b.
       `Y$$b.
          `"Y$b._
              `"""

OpenBSD VM (VirtualBox on Radxa X4)

                                     _    root@openbsd.local
                                    (_)   ------------------
              |    .                       OS: OpenBSD 7.7 amd64
          .   |L  /|   .          _       Host: VirtualBox 1.2
      _ . |\ _| \--+._/| .       (_)      Kernel: 7.7 GENERIC#91
     / ||\| Y J  )   / |/| ./             Uptime: 2 hours, 11 mins
    J  |)'( |        ` F`.'/        _     Packages: 73 (pkg_info)
  -<|  F         __     .-<        (_)    Shell: ksh v5.2.14
    | /       .-'. `.  /-. L___           Terminal: /dev/ttyp0
    J \      <    \  | | O\|.-'  _        CPU: Intel N100 (1) @ 3.392GHz
  _J \  .-    \/ O | | \  |F    (_)       Memory: 187MiB / 985MiB
 '-F  -<_.     \   .-'  `-' L__
__J  _   _.     >-'  )._.   |-'
`-|.'   /_.           \_|   F
  /.-   .                _.<
 /'    /.'             .'  `\
  /L  /'   |/      _.-'-\
 /'J       ___.---'\|
   |\  .--' V  | `. `
   |/`. `-.     `._)
      / .-.\
      \ (  `\
       `.\

Benchmark Results

Compilation Time Summary (seconds)

Rank	System	Average	Min	Max	Std Dev	Speedup
1	Ubuntu x86_64	13.71	13.61	13.76	0.08	34.34x
2	Orange Pi 5 Max	58.65	57.98	59.32	0.95	8.03x
3	Raspberry Pi CM5	69.71	69.30	70.06	0.38	6.75x
4	Banana Pi R2 Pro	418.18	416.96	419.67	1.38	1.13x
5	OpenBSD 7.7	470.67	467.00	473.00	2.88	1.00x

Note: Speedup is calculated relative to the slowest system (OpenBSD)

Individual Run Times

Ubuntu x86_64 (AMD AI Max+ 395)

Run 1: 13.76s
Run 2: 13.65s
Run 3: 13.61s
Average: 13.71s

Orange Pi 5 Max

Run 1: 57.98s
Run 2: 59.32s
Run 3: 58.65s
Average: 58.65s

Raspberry Pi CM5

Run 1: 69.77s
Run 2: 70.06s
Run 3: 69.30s
Average: 69.71s

Banana Pi R2 Pro

Run 1: 417.91s
Run 2: 419.67s
Run 3: 416.96s
Average: 418.18s

OpenBSD 7.7

Run 1: 473.00s
Run 2: 467.00s
Run 3: 472.00s
Average: 470.67s

Performance Analysis

Architecture Comparison

x86_64 Performance

The AMD Ryzen AI Max+ 395 demonstrates exceptional performance with sub-14 second builds
OpenBSD VM shows significantly slower performance, likely due to:
Running in VirtualBox virtualization layer
Limited memory allocation (1GB)
Host system (Radxa X4 with Intel N100) performance constraints

ARM64 Performance Tiers

Tier 1: High Performance (< 1 minute) - Orange Pi 5 Max: Benefits from RK3588's big.LITTLE architecture with 4x Cortex-A76 + 4x Cortex-A55

Tier 2: Good Performance (1-2 minutes) - Raspberry Pi CM5: Solid performance with 4x Cortex-A76 cores

Tier 3: Acceptable Performance (5-10 minutes) - Banana Pi R2 Pro: Older RK3568 SoC shows its limitations - Pine64 Quartz64 B: Similar performance tier with RK3566

Key Observations

CPU Architecture Impact: Modern Cortex-A76 cores (Orange Pi 5 Max, Raspberry Pi CM5) significantly outperform older designs
Core Count vs Performance: The 8-core Orange Pi 5 Max only marginally outperforms the 4-core Raspberry Pi CM5, suggesting diminishing returns from parallelization in Rust compilation
Memory Constraints: The Banana Pi R2 Pro with only 2GB RAM may be experiencing memory pressure during compilation
Operating System Overhead: OpenBSD shows significantly higher compilation times, possibly due to:
Less optimized Rust toolchain
Different memory management
Security features adding overhead

Visualizations

Charts include: - Average compilation time comparison - Distribution of compilation times (box plot) - Relative performance comparison - Min-Max ranges for each system

Conclusions

Best Value Propositions

Best Overall Performance: Ubuntu x86_64 with AMD AI Max+ 395
34x faster than slowest system
Ideal for development workstations
Best ARM SBC: Orange Pi 5 Max
8x faster than slowest system
Good balance of performance and likely cost
16GB RAM provides headroom for larger projects
Budget ARM Option: Raspberry Pi CM5
6.75x faster than slowest system
Well-supported ecosystem
Consistent performance

Recommendations

For CI/CD pipelines: Use x86_64 cloud instances or the AMD system for fastest builds
For ARM development: Orange Pi 5 Max or Raspberry Pi CM5 provide reasonable compile times
For learning/hobbyist use: Any of the faster ARM boards are suitable
Avoid for compilation: Systems with < 4GB RAM or older ARM cores (pre-A76)

Methodology

Test Procedure

Installed Rust toolchain (v1.90.0) on all systems
Cloned the ballistics-engine repository
Performed initial build to download all dependencies
Executed 3 clean release builds on each system
Measured wall-clock time for each compilation
Calculated averages and standard deviations

Test Conditions

All systems were connected via local network (10.1.1.x)
SSH was used for remote execution
No other significant workloads during testing
Release build profile was used (cargo build --release)

Limitations

Pine64 Quartz64 B benchmark was incomplete
OpenBSD tested in VirtualBox VM with limited resources
Network conditions may have affected initial dependency downloads (not measured)
Different Rust versions on OpenBSD (1.86.0) vs others (1.90.0)

Future Work

Benchmark incremental compilation times
Test with different optimization levels
Compare power consumption during compilation
Test with larger Rust projects
Include more x86_64 systems for comparison
Measure peak memory usage during compilation