Rust by itself is only capable of cross-compiling static libraries. Anything else requires extra dependencies and configuration. You will also need a linker capable of creating Linux binaries, Linux version of libc, and most likely also Linux-compatible C compiler and Debian libraries that dependenc… Answer from kornel on users.rust-lang.org
HackerNoon
hackernoon.com › building-a-wireless-thermostat-in-rust-for-raspberry-pi-part-2
Rust Cross Compiling to the Raspberry Pi | HackerNoon
October 31, 2022 - Efficiently set up a development environment for cross-compiling Rust code for other platforms, including Raspberry Pi and AWS Lambda.
GitHub
github.com › robamu-org › rpi-rs-crosscompile
GitHub - robamu-org/rpi-rs-crosscompile: Cross-compile and Debug Rust applications for the Raspberry Pi with the CLI and with VS Code · GitHub
Cross-compile and Debug Rust applications for the Raspberry Pi with the CLI and with VS Code - robamu-org/rpi-rs-crosscompile
Author robamu-org
What steps are needed to cross-compile a program that runs on my raspberry pi zero 2 w?
I am also not entirely sure what toolchain means in this context. I already have a toolchain installed through rustup don't I? Why do I need additional files? Consider this: when you build a program for Windows, the binary that it spits out isn't going to run on Linux, and vice versa. There are "platform libraries" that do different things on different systems, and you need to pick one to use. When you do a normal install of Rust on your system, you get a version of Rust that runs on your system, and that also has all the files necessary to produce binaries for your system. By installing a different "toolchain", you're still using a version of Rust that runs on your system, but you're getting all the libraries (and potentially other tools) needed to produce binaries for some other systems. As far as Rust is concerned, if you've already done rustup target add arm-unknown-linux-gnueabihf then there's probably nothing more to do there. I would try using the official OS and cross-compiling like you successfully did before just to see if it works on the new machine. If so, then it sounds like the question is with Arch Linux. More on reddit.com
5
2
July 6, 2024Has anyone programmed a Raspberry Pi with Rust?
(I'm assuming crosscompiling then running on Linux, not bare-metal (but that also should be possible)) Not a big project, but I've run simple HTTP server on one. To be honest, with Rust it mostly just:
rustup target add arm-unknown-linux-musleabihf cargo build --target arm-unknown-linux-musleabihf
You might need to adjust target, depending on which Raspberry Pi version you're using.
In my case, because I've fairly old one (RPi 1 B+), I had to additionally download gcc toolchain (for linking) from arm's website, as the one from distro didn't support armv6.
More on reddit.com 25
57
July 1, 2022How can I compile Rust code to run on a Raspberry Pi 2? - Stack Overflow
I recently acquired a Raspberry PI 2 and I want to run a Rust program on it. Is there a guide/instructions how to cross compile Rust programs on Raspberry PI 2? I've heard about running Rust on R... More on stackoverflow.com
PSA: For cross-compiling please use the "Cross" tool.
I typically cross compile for different architectures on Linux and have found great success with using mold instead of cross. To make statically linked musl binaries you can add this .cargo/config.toml file: # Linker options for MUSL targets. We need to manually specify --target as cargo # doesn't do that for us by default [target.x86_64-unknown-linux-musl] linker = "clang" rustflags = [ "-C", "link-arg=-fuse-ld=mold", "-C", "link-arg=--target=x86_64-unknown-linux-musl", ] [target.aarch64-unknown-linux-musl] linker = "clang" rustflags = [ "-C", "link-arg=-fuse-ld=mold", "-C", "link-arg=--target=aarch64-unknown-linux-musl", ] And then compile using cargo build --release --target aarch64-unknown-linux-musl This works great in CI as well (with the drawback that you need clang installed as well). Extract from my gitlab ci: .mold: setup: # Install the latest available Clang version in Bullseye - apt-get update - DEBIAN_FRONTEND=noninteractive apt-get install -y clang-13 # Clang is installed with a prefix, which is not what we want - ln -s /usr/bin/clang-13 /usr/bin/clang - clang --version # Install mold - curl -L -o mold.tar.gz https://github.com/rui314/mold/releases/download/v2.1.0/mold-2.1.0-x86_64-linux.tar.gz - echo "67a479bf2eddf10dd223e488ceedddca49174f629f7a4bbaeaab80c5b5702021 mold.tar.gz"|sha256sum --check --status - tar -xz --strip-components=1 -C /usr/ -f mold.tar.gz - rm mold.tar.gz - mold --version build-aarch64-musl: stage: deploy needs: - test script: - !reference [.mold, setup] - rustup target add aarch64-unknown-linux-musl - cargo build --release --target aarch64-unknown-linux-musl artifacts: paths: - target/aarch64-unknown-linux-musl/release/binary More on reddit.com
30
103
January 5, 2024Videos
Rust, RaspberryPi and RTC/I2C Hacking LIVE! (ft. macOS to ...
Rust Cross-Compile for Windows on Linux | Arch/Manjaro/EndeavourOS ...
07:15
Rust Raspberry PI Setup | Tutorial - YouTube
05:58
Cross Compiling Golang Applications For Use On A Raspberry Pi - ...
12:46
Programming Rust on Your Raspberry Pi Remotely Using VS Code - YouTube
08:32
T2: C++ Cross Compile for Arm32 on Raspberry Pi (Beginner Level) ...
Top answer 1 of 7
1
Rust by itself is only capable of cross-compiling static libraries. Anything else requires extra dependencies and configuration. You will also need a linker capable of creating Linux binaries, Linux version of libc, and most likely also Linux-compatible C compiler and Debian libraries that dependenc…
2 of 7
0
Thanks for your reply, but after using cargo zigbuild --target armv7-unknown-linux-musleabihf still reports an error
failed to run custom build command for openssl-sys v0.9.82
failed to run custom build command for zstd-sys v2.0.7+zstd.1.5.4
But I will not achieve similar problems by running dire…
Reddit
reddit.com › r/rust › what steps are needed to cross-compile a program that runs on my raspberry pi zero 2 w?
r/rust on Reddit: What steps are needed to cross-compile a program that runs on my raspberry pi zero 2 w?
July 6, 2024 -
Hi, I already succeeded partially in this as I compiled a rust program for my raspberry pi zero w (the first version). Let's call that one rp0w1 and the new version rp0w2 for clarity.
On my rp0w1 I run rasberry pi os, because that's the only OS supported. I oriented myself on this blog post: link
On the rp0w2 I am running arch linux (arm) though, because I prefer it. And the toolchain isn't correct (the one also mentioned in the blog post).
I would like to know what steps would be needed in order to get a binary that I can run on my rp0w2. I am also not entirely sure what toolchain means in this context. I already have a toolchain installed through rustup don't I? Why do I need additional files?
Can I simply download some files from ARM or what do I do?
Top answer 1 of 4
9
I am also not entirely sure what toolchain means in this context. I already have a toolchain installed through rustup don't I? Why do I need additional files? Consider this: when you build a program for Windows, the binary that it spits out isn't going to run on Linux, and vice versa. There are "platform libraries" that do different things on different systems, and you need to pick one to use. When you do a normal install of Rust on your system, you get a version of Rust that runs on your system, and that also has all the files necessary to produce binaries for your system. By installing a different "toolchain", you're still using a version of Rust that runs on your system, but you're getting all the libraries (and potentially other tools) needed to produce binaries for some other systems. As far as Rust is concerned, if you've already done rustup target add arm-unknown-linux-gnueabihf then there's probably nothing more to do there. I would try using the official OS and cross-compiling like you successfully did before just to see if it works on the new machine. If so, then it sounds like the question is with Arch Linux.
2 of 4
4
I personally use https://github.com/cross-rs/cross After setting up you can build for a pi just by running: cross build --release --target=aarch64-unknown-linux-gnu
Medium
medium.com › swlh › compiling-rust-for-raspberry-pi-arm-922b55dbb050
Compile Rust for Raspberry Pi ARM | by Tiziano Santoro | The Startup | Medium
October 17, 2020 - In this article we will build a simple HTTP server application in Rust, cross-compile it for the Raspberry Pi ARM architecture, deploy it to a Raspberry Pi board over a network connection, and install it as a persistent service so that it restarts automatically at boot time and upon crash.
fabian writes.
capnfabs.net › posts › cross-compiling-rust-apps-raspberry-pi
Cross-Compiling Rust apps for the Raspberry Pi || fabian writes.
October 22, 2020 - Now, we can theoretically tell the Ubuntu install on the Docker container to “enable the Raspberry Pi architecture (armhf) and install the required packages”: # Use the container that comes with `cross` as a base. It's already got # a cross-compile toolchain installed, so that's less work for us. FROM rustembedded/cross:armv7-unknown-linux-gnueabihf-0.2.1 RUN apt-get update RUN dpkg --add-architecture armhf && \ apt-get update && \ apt-get install --assume-yes libssl-dev:armhf libasound2-dev:armhf
GitHub
github.com › joachimBurket › raspberrypi-cross-compile-rust
GitHub - joachimBurket/raspberrypi-cross-compile-rust: Cross compile a rust app on a Raspberry pi
$ file cross-compile-rpi cross-compile-rpi: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked, with debug_info, not stripped $ ls -lh cross-compile-rpi -rwxr-xr-x 1 pi pi 4.9M May 31 11:38 cross-compile-rpi · To accelerate the development, a Justfile (from just tool, see this cheatsheet to get started) has been made: # list the recipes with: Available recipes: build PROFILE="dev" # Build and push the binary for the target default # List all available recipes # build the code, and push it to the Raspberrypi just build # build the code with the `release` profile (see the default profiles here: https://doc.rust-lang.org/cargo/reference/profiles.html#default-profiles), and push it just build release
Author joachimBurket
Reddit
reddit.com › r/rust › has anyone programmed a raspberry pi with rust?
r/rust on Reddit: Has anyone programmed a Raspberry Pi with Rust?
July 1, 2022 -
If you’ve worked on any projects using Rust and a Raspberry Pi I would be interested to hear your story.
Top answer 1 of 15
56
Cross-compiling to Raspberry PI is easy, and works great. Compiling on a Raspberry PI is rather painful due to long compile times.
2 of 15
29
(I'm assuming crosscompiling then running on Linux, not bare-metal (but that also should be possible)) Not a big project, but I've run simple HTTP server on one. To be honest, with Rust it mostly just:
rustup target add arm-unknown-linux-musleabihf
cargo build --target arm-unknown-linux-musleabihfYou might need to adjust target, depending on which Raspberry Pi version you're using.
In my case, because I've fairly old one (RPi 1 B+), I had to additionally download gcc toolchain (for linking) from arm's website, as the one from distro didn't support armv6.
DEV Community
dev.to › carolineee › how-to-use-cargo-to-cross-compile-rust-programs-for-raspberry-pi-26l
How to use Cargo to cross compile Rust programs for Raspberry Pi? - DEV Community
August 28, 2025 - # 1) Install cargo install cross rustup target add aarch64-unknown-linux-gnu # 64-bit Pi OS rustup target add armv7-unknown-linux-gnueabihf # 32-bit Pi 2/3/4 OS rustup target add arm-unknown-linux-gnueabihf # ARMv6 (Pi Zero/1) # 2) Build cross build --target aarch64-unknown-linux-gnu --release # or: cross build --target armv7-unknown-linux-gnueabihf --release # or: cross build --target arm-unknown-linux-gnueabihf --release # 3) Copy & run on the Pi scp target/<target>/release/yourapp pi@raspberrypi.local:/home/pi/ ssh pi@raspberrypi.local ./yourapp
Chacin
chacin.dev › blog › cross-compiling-rust-for-the-raspberry-pi
Cross Compiling Rust for the Raspberry Pi | Carlos Chacin
January 28, 2020 - [build] # Pi 0/1 [target.arm-unknown-linux-gnueabihf] linker = "arm-linux-gnueabihf-gcc" # Pi 2/3/4 [target.armv7-unknown-linux-gnueabihf] linker = "arm-none-linux-gnueabihf-gcc" # (Optional) Set default target for cargo build # target = "armv7-unknown-linux-gnueabihf" # rustflags = ["-C", "linker=arm-none-linux-gnueabihf-gcc"] Below is a quick example workflow you can use to quickly deploy your project on a Pi. ... PI_IP=192.168.2.159 # Be sure to change this! TARGET=armv7-unknown-linux-gnueabihf # Pi 2/3/4 #TARGET=arm-unknown-linux-gnueabihf # Pi 0/1 # build binary cargo build --target $TARGET # upload binary sshpass -p 'raspberry' scp -r ./target/$TARGET/debug/pi_project pi@$PI_IP:/home/pi # execute binary sshpass -p 'raspberry' ssh pi@$PI_IP './pi_project'
Sebastian Aigner
sebi.io › posts › 2024-05-02-guide-cross-compiling-rust-from-macos-to-raspberry-pi-2024-apple-silicon
Guide: Cross-compiling Rust from macOS to Raspberry Pi (2024, Apple Silicon) | Sebastian Aigner
May 2, 2024 - reqwest = { version = "0.11.23", features = ["json", "rustls"], default-features = false } Enjoy building some oxidized binaries for your Raspberry!
S2e-systems
s2e-systems.github.io › Rust-RPi4-Windows-Cross-Compilation
Rust Raspberry Pi 4 cross-compilation from Windows
August 27, 2019 - If this is not done, a error: linker cc not found message shows up when trying to compile an executable for that target. To create a Rust “Hello World” program, simply make a new folder (in this case I call it rs-hello) and let cargo do the rest of the work for you. cargo init cargo build --target=armv7-unknown-linux-gnueabihf · Now there is an executable that can be copied and executed on the remote Raspberry Pi.
paullj
paullj.github.io › posts › cross-compiling-rust-for-raspberry-pi-development
Cross-Compiling Rust for Raspberry Pi Development • paullj
September 9, 2024 - It acts as a drop in replacement for cargo build and cargo run, but it handles all the cross-compilation for you. You can specify the target architecture with the --target flag, but you can also specify a default in a Cross.toml file. For example if you’re targeting Raspberry Pi OS Lite 64-bit, you can use something like this:
Sysdev
sysdev.me › 2025 › 11 › 27 › cross-compiling-rust-for-raspberry-pi
Cross-Compiling Rust for Raspberry Pi - CodeBlueprint
November 27, 2025 - Even this tiny example should have some issues during cross-compilation: the v4l crate, bindgen, and the need for the correct libclang inside the build environment. You can easily wire the toolchain manually. It usually starts like this: sudo apt install gcc-aarch64-linux-gnu rustup target add aarch64-unknown-linux-gnu
GitHub
github.com › Ragnaroek › rust-on-raspberry-docker
GitHub - Ragnaroek/rust-on-raspberry-docker: cross compiling rust for the raspberry pi in a docker container
By setting different tags for your Docker image and RUST_VERSION you could easily build images for different version of rust and use them as need. Cross-compiling with your own build image works exactly as with the one pulled from the dockerhub.
Starred by 81 users
Forked by 23 users
Languages Shell 75.9% | Dockerfile 24.1% | Shell 75.9% | Dockerfile 24.1%
DEV Community
dev.to › h_ajsf › cross-compiling-rust-for-raspberry-pi-4iai
Cross compiling Rust for Raspberry Pi - DEV Community
September 11, 2019 - Hasans-Air:rpi hasan$ cargo build Compiling rpi v0.1.0 (/Users/hasan/PycharmProjects/rpi) Finished dev [unoptimized + debuginfo] target(s) in 0.41s Hasans-Air:rpi hasan$ scp target/armv7-unknown-linux-musleabihf/debug/rpi pi@192.168.1.43: pi@192.168.1.43's password: rpi 100% 2702KB 2.6MB/s 00:01 Hasans-Air:rpi hasan$ ssh pi@192.168.1.43 'chmod +x ~/rpi && ~/rpi' pi@192.168.1.43's password: Hello, Raspberry!
GitHub
github.com › Ogeon › rust-on-raspberry-pi
GitHub - Ogeon/rust-on-raspberry-pi: [OUTDATED] Instructions for how to cross compile Rust projects for the Raspberry Pi
The first step is to download the Raspberry Pi toolchain. It's a collection of binaries and libraries for cross compiling. Begin by installing git if it's not already installed: ... The next step is to compile the Rust compiler and standard ...
Starred by 290 users
Forked by 15 users
Languages Shell 100.0% | Shell 100.0%
Honeytreelabs
honeytreelabs.com › posts › cross-building-rust-app-for-openwrt
Cross building Rust applications for Raspberry Pis
July 31, 2024 - We are now able to build Rust applications for the Raspberry Pi platform. In this blog post, we built a custom C/C++ toolchain for Raspberry Pi SBCs running OpenWrt to enable the compilation of Rust applications that require such a toolchain for integrating dependent libraries.
Jakewharton
jakewharton.com › cross-compiling-static-rust-binaries-in-docker-for-raspberry-pi
Cross-compiling static Rust binaries in Docker for Raspberry Pi – Jake Wharton
May 27, 2021 - This allows compilation and optimization to have the maximum impact by always seeing the entire program. Having starting with only the Pi 3b and needing ARMv7, getting the build going in Docker was not too difficult. We basically just run the commands from above to produce the binary and then copy that into an Alpine container. FROM rust:1.52.1 AS rust RUN rustup target add armv7-unknown-linux-musleabihf RUN apt-get update && apt-get -y install binutils-arm-linux-gnueabihf WORKDIR /app COPY .cargo ./.cargo COPY Cargo.toml Cargo.lock .rustfmt.toml ./ COPY src ./src RUN cargo build --release --target armv7-unknown-linux-musleabihf FROM --platform linux/arm alpine:3.12 WORKDIR /app COPY --from=rust /app/target/armv7-unknown-linux-musleabihf/release/normally-closed ./ # ENTRYPOINT setup...
Top answer 1 of 3
31
We have rustup now.
$ rustup target add arm-unknown-linux-gnueabihf
$ sudo apt-get install gcc-arm-linux-gnueabihf
$ echo '[target.arm-unknown-linux-gnueabihf]' >> ~/.cargo/config
$ echo 'linker = "arm-linux-gnueabihf-gcc"' >> ~/.cargo/config
$ cd <project dir>
$ cargo build --target=arm-unknown-linux-gnueabihf
2 of 3
9
The Rust compiler is not distributed as a cross-compiler for the Raspberry Pi, so it needs to be compiled as a cross compiler with rpi dev tools.
Get rpi dev tools -
git clone https://github.com/raspberrypi/tools.git ~/pi-toolsget rust compiler from mozilla git repo and add rpi tools to the path
export PATH=~/pi-tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin:$PATHLook for rusty-pi dir on your home
./configure --target=arm-unknown-linux-gnueabihf --prefix=$HOME/rusty-pi && make && make installConsidering helloworld.rs ->
% ~/pi-rust/bin/rustc --target=arm-unknown-linux-gnueabihf -C linker=arm-linux-gnueabihf-g++ helloworld.rs
It will produce an executable.