# How to Configure ARM/aarch64 Architecture Support with binfmt for InternetIncome > Configure ARM aarch64 architecture support with binfmt for InternetIncome. Use the script with --install or manually execute the Docker binfmt container and install QEMU packages. Get started today. - Repository: [engageub/internetincome](https://github.com/engageub/internetincome) - Tags: how-to-guide - Published: 2026-03-01 --- **To configure ARM/aarch64 architecture support with binfmt for InternetIncome, run the script with `--install` on an ARM host to automatically detect the architecture and install the `binfmt_misc` emulator, or manually execute the Docker binfmt container and install QEMU packages.** The InternetIncome script by **engageub/internetincome** orchestrates multiple Docker containers to generate passive income, but most images are compiled for `amd64` architectures. By configuring ARM/aarch64 architecture support with binfmt, you enable transparent binary translation that allows these x86_64 containers to run natively on Raspberry Pi, AWS Graviton, and other ARM-based systems without modifying the images themselves. ## How Automatic binfmt Configuration Works The script contains built-in logic to detect non-x86 architectures and automatically configure the necessary emulation layer. This eliminates manual kernel configuration while ensuring Docker can execute cross-platform binaries seamlessly. ### Architecture Detection in the Script At startup, the script checks the host CPU architecture using standard system commands. In [`internetIncome.sh`](https://github.com/engageub/internetincome/blob/main/internetIncome.sh) at line 1112, the detection logic captures the machine hardware name: ```bash CPU_ARCH=`uname -m` ``` When the value returns `aarch64` or `arm64`, the script triggers the binfmt installation routine instead of proceeding with standard Docker operations. This conditional check ensures the setup only runs on ARM hosts where emulation is required. ### The binfmt Installation Process Upon detecting an ARM architecture, the script executes two critical operations in sequence. First, it registers QEMU static binaries with the kernel's `binfmt_misc` handler by running the official multi-architecture support container. Line 1113 of [`internetIncome.sh`](https://github.com/engageub/internetincome/blob/main/internetIncome.sh) shows this command: ```bash sudo docker run --privileged --rm tonistiigi/binfmt --install all ``` Immediately following this, the script installs the supporting QEMU packages to handle the actual binary translation. At line 1114, it executes: ```bash sudo apt-get install qemu binfmt-support qemu-user-static ``` These steps register interpreters for `amd64` (and other architectures) in the kernel, allowing Docker to transparently translate x86_64 instructions to ARM64 at runtime. ## Step-by-Step Configuration Guide You can enable ARM support through the script's automated installer or manually configure the system if you need custom control over the process. ### Automatic Setup via the Install Flag The recommended approach uses the script's built-in detection and installation routine. This method is documented in the project's [`README.md`](https://github.com/engageub/internetincome/blob/main/README.md) at lines 78-82 and handles all dependencies automatically. Execute these commands on your ARM device: ```bash # 1. Install Docker if not already present sudo apt-get update sudo apt-get -y install docker.io # 2. Run the script's install routine to trigger binfmt setup sudo bash internetIncome.sh --install ``` During execution, the script detects the `aarch64` architecture and outputs confirmation that it is installing binfmt for amd64 support. Once completed, the environment persists across reboots and applies to all subsequent Docker operations. ### Manual binfmt Configuration If you prefer to configure the system without using the `--install` flag, or if you need to troubleshoot the automatic setup, run these commands manually: ```bash # Register QEMU handlers for all supported architectures sudo docker run --privileged --rm tonistiigi/binfmt --install all # Install QEMU user-mode emulation and binfmt support packages sudo apt-get install qemu binfmt-support qemu-user-static ``` After running these commands, verify the registration by listing the registered interpreters. You should see handlers for `qemu-amd64` among other architectures, confirming that the system can now execute x86_64 binaries. ## Verifying Your Configuration Confirm that binfmt is properly configured before starting the main InternetIncome services. Run the Docker binfmt container again to display currently registered interpreters: ```bash docker run --rm --privileged tonistiigi/binfmt --install all ``` Look for `qemu-amd64` in the output list. Once confirmed, start the InternetIncome containers normally: ```bash sudo bash internetIncome.sh --start ``` The script will now pull and execute `amd64` images such as `ghcr.io/heiher/hev-socks5-tunnel` and `honeygain/honeygain` without architecture errors. ## Summary - The InternetIncome script detects ARM/aarch64 hosts at line 1112 of [`internetIncome.sh`](https://github.com/engageub/internetincome/blob/main/internetIncome.sh) using `uname -m` and automatically installs binfmt support when needed. - **Automatic configuration** requires only running `sudo bash internetIncome.sh --install` on your ARM device. - **Manual configuration** involves executing the `tonistiigi/binfmt` Docker container and installing `qemu`, `binfmt-support`, and `qemu-user-static` packages. - The binfmt emulator translates `amd64` binaries at runtime, enabling seamless execution of x86_64 Docker images on Raspberry Pi, AWS Graviton, and other ARM servers. - Configuration changes persist across reboots and apply system-wide to all Docker containers. ## Frequently Asked Questions ### What is binfmt and why does InternetIncome need it on ARM? **binfmt_misc** is a Linux kernel feature that enables the kernel to recognize arbitrary executable file formats and pass them to user-space interpreters. InternetIncome requires it on ARM hosts because the majority of income-generating containers (such as proxy tunnels and bandwidth-sharing applications) are compiled for the `amd64` architecture. Without binfmt and QEMU user-mode emulation, the ARM kernel cannot execute x86_64 machine code, causing containers to fail immediately with "exec format error" messages. ### Can I run InternetIncome on a Raspberry Pi without binfmt? No, you cannot run the standard InternetIncome configuration on a Raspberry Pi without binfmt unless every container image you deploy has been specifically compiled for the `arm64` architecture. Since the script pulls official images like `honeygain/honeygain` and `ghcr.io/heiher/hev-socks5-tunnel` that are only distributed as `amd64` binaries, binfmt is mandatory for translation. The script automatically detects this requirement and refuses to proceed with incompatible containers until the emulator is installed. ### Is the binfmt configuration persistent across reboots? Yes, once you register the QEMU interpreters using the `tonistiigi/binfmt` container, the registration persists across system reboots. The kernel stores binfmt interpreter registrations in a virtual filesystem that survives restarts. However, if you reinstall the operating system or reset Docker's runtime configuration, you must rerun the installation command or execute `internetIncome.sh --install` again to restore ARM/aarch64 architecture support. ### How do I troubleshoot if amd64 containers still fail to start? First, verify that the binfmt handler is registered by running `docker run --rm --privileged tonistiigi/binfmt --install all` and checking for `qemu-amd64` in the output. If the handler is missing, ensure the `qemu-user-static` package is installed correctly using `sudo apt-get install qemu-user-static`. Second, check that you are running Docker with sufficient privileges, as the binfmt registration requires access to the host kernel. Finally, confirm your Docker daemon supports multi-architecture manifests by running `docker manifest inspect ` to verify the amd64 layer is available.