--- title: "Embedded" description: "Embedded Platforms on which Slint has been tested" --- {/* cSpell: ignore Toradex Vivante espflash pico armhf armhf THUMBV EABIHF eabihf eabi bootsel udisksctl picotool */} import { Tabs, TabItem } from '@astrojs/starlight/components'; import ReleaseLink from '@slint/common-files/src/components/ReleaseLink.astro'; Slint runs on many embedded platforms. The platform descriptions below cover what has been tested for deployment. For the development environment, we recommend using a recent desktop operating system and compiler version. ## Embedded Linux Slint runs on a variety of embedded Linux platforms. Generally speaking, Slint requires a modern Linux userspace with working OpenGL ES 2.0 (or newer) or Vulkan drivers. We've had success running Slint on - Yocto based distributions. - BuildRoot based distributions. - Torizon. For C++ applications see [meta-slint](https://github.com/slint-ui/meta-slint) for recipes. Rust applications work out of the box with Yocto's Rust support. Toradex provides [Torizon OS](https://developer.toradex.com/torizon/), a Linux based platform for its embedded devices that packages applications in docker containers. We provide our demos compiled for Toradex as docker containers with and without GPU acceleration support. #### Prerequisites - A device running Torizon OS 6.0 or later - SSH access to the Torizon device - Docker installed on the device **Note**: The Slint demos run directly on the linux/kms and do not require a Weston container. #### Running Our pre-compiled demos are available in multiple variants optimized for different hardware platforms: 1. **Standard ARM64 without GPU build** (`torizon-demos-arm64`) - Uses software rendering 2. **i.MX8 GPU build** (`torizon-demos-arm64-imx8`) - Optimized for i.MX8 series with GPU acceleration 3. **AM62 GPU build** (`torizon-demos-arm64-am62`) - Optimized for AM62 series with GPU acceleration 4. **i.MX95 GPU build** (`torizon-demos-arm64-imx95`) - Optimized for i.MX95 series with GPU acceleration A complete list of all containers can be found at https://github.com/orgs/slint-ui/packages?q=torizon&tab=packages&q=torizon For example, to run the container on an i.MX8 board with GPU, deploy the following `docker-compose.yaml` with Docker Compose: ```yaml services: slint-demo: image: ghcr.io/slint-ui/slint/torizon-demos-arm64-imx8:latest restart: unless-stopped environment: - ACCEPT_FSL_EULA=1 user: torizon privileged: true volumes: - type: bind source: /tmp target: /tmp - type: bind source: /dev target: /dev - type: bind source: /run/udev target: /run/udev device_cgroup_rules: # ... for tty - "c 4:* rmw" # ... for /dev/input devices - "c 13:* rmw" - "c 199:* rmw" # ... for /dev/dri devices - "c 226:* rmw" ``` :::note[Note] Change the `image` to match your hardware platform: | Platform | Image | | ------------- | --------------------------------------------------------- | | ARM64 no GPU | `ghcr.io/slint-ui/slint/torizon-demos-arm64:latest` | | i.MX8 w/ GPU | `ghcr.io/slint-ui/slint/torizon-demos-arm64-imx8:latest` | | AM62 w/ GPU | `ghcr.io/slint-ui/slint/torizon-demos-arm64-am62:latest` | | i.MX95 W/ GPU | `ghcr.io/slint-ui/slint/torizon-demos-arm64-imx95:latest` | ::: Alternative, run the container with the following command line: ``` sudo docker run --rm --privileged \ --user=torizon \ -v /dev:/dev \ -v /tmp:/tmp \ -v /run/udev:/run/udev \ --device-cgroup-rule='c 199:* rmw' \ --device-cgroup-rule='c 226:* rmw' \ --device-cgroup-rule='c 13:* rmw' \ --device-cgroup-rule='c 4:* rmw' \ ghcr.io/slint-ui/slint/torizon-demos-arm64-imx8 ``` #### Selecting Demos By default, the **home-automation** demo is run. The containers package multiple demo applications: * **home-automation** (default) - Smart home control panel * **energy-monitor** - Energy monitoring dashboard * **printerdemo** - 3D printer control interface * **gallery** - Image gallery with touch navigation * **slide_puzzle** - Interactive sliding puzzle game * **opengl_underlay** - OpenGL rendering demonstration * **carousel** - 3D carousel interface * **todo** - Task management application * **weather-demo** - Weather information display (requires API key) Run a specific demo by specifying it as a parameter to `docker run`, for example: ``` sudo docker run --rm --privileged --user=torizon \ -v /dev:/dev -v /tmp:/tmp -v /run/udev:/run/udev \ --device-cgroup-rule='c 199:* rmw' --device-cgroup-rule='c 226:* rmw' \ --device-cgroup-rule='c 13:* rmw' --device-cgroup-rule='c 4:* rmw' \ ghcr.io/slint-ui/slint/torizon-demos-arm64-imx8 printerdemo ``` ## Microcontrollers Slint's platform abstraction allows for integration into any Rust or C++ based Microcontroller development environment. Developers need to implement functionality to feed input events such as touch or keyboard, as well as displaying the pixels rendered by Slint into a frame- or linebuffer. You will need to use the `mcu-board-support` crate. This crate re-export a `entry` attribute macro to apply to the `main` function, and a `init()` function that should be called before creating the Slint UI. In order to use this backend, the final program must depend on both `slint` and `mcu-board-support`. The main.rs will look something like this ```rust #![no_std] #![cfg_attr(not(feature = "simulator"), no_main)] slint::include_modules!(); #[allow(unused_imports)] use mcu_board_support::prelude::*; #[mcu_board_support::entry] fn main() -> ! { mcu_board_support::init(); MainWindow::new().run(); panic!("The event loop should not return"); } ``` Since mcu-board-support is at the moment an internal crate not uploaded to crates.io, you must use the git version of slint, slint-build, and mcu-board-support ```toml [dependencies] slint = { git = "https://github.com/slint-ui/slint", default-features = false } mcu-board-support = { git = "https://github.com/slint-ui/slint" } # ... [build-dependencies] slint-build = { git = "https://github.com/slint-ui/slint" } ``` In your build.rs, you must include a call to `slint_build::print_rustc_flags().unwrap()` to set some of the flags. We provide templates for a few off-the-shelf development boards from some of the silicon vendors. The Rust sections below show how to run the Slint Printer demo on various boards. The commands are meant to be run from the root of a checkout of the [Slint repository](https://github.com/slint-ui/slint); the demo lives in the `demos` Cargo workspace, hence the explicit `--manifest-path`. ### Espressif (ESP32) #### Prerequisites * ESP Rust Toolchain: https://esp-rs.github.io/book/installation/installation.html * `espflash`: Install via `cargo install espflash`. When flashing, with `espflash`, you will be prompted to select a USB port. If this port is always the same, then you can also pass it as a parameter on the command line to avoid the prompt. For example if `/dev/ttyUSB1` is the device file for your port, the command line changes to `espflash --monitor /dev/ttyUSB1 path/to/binary/to/flash_and_monitor`. #### ESP32-S3-Box-3 To compile and run the Slint Printer demo: ```sh CARGO_PROFILE_RELEASE_OPT_LEVEL=s cargo +esp run --manifest-path demos/printerdemo_mcu/Cargo.toml --target xtensa-esp32s3-none-elf --no-default-features --features=mcu-board-support/esp32-s3-box-3 --release --config examples/mcu-board-support/esp32_s3_box_3/cargo-config.toml ``` To use Slint with your C++ application, you can follow the instructions on the [Espressif Documentation site](https://components.espressif.com/components/slint/slint) ### ST (STM32) Follow the steps below to run the Slint Printer Demo #### STM32H735G-DK Using [probe-rs](https://probe.rs). ```sh CARGO_PROFILE_RELEASE_OPT_LEVEL=s CARGO_TARGET_THUMBV7EM_NONE_EABIHF_RUNNER="probe-rs run --chip STM32H735IGKx" cargo run --manifest-path demos/printerdemo_mcu/Cargo.toml --no-default-features --features=mcu-board-support/stm32h735g --target=thumbv7em-none-eabihf --release ``` #### STM32H735G-DK You can start with the template #### STM32H747I-DISCO You can start with the template ### Raspberry Pi (Pico) Only Rust programs are currently supported on the Raspberry Pi Pico. #### On the Raspberry Pi Pico Ensure the right target is set: ```sh rustup target add thumbv6m-none-eabi ``` Build the Slint Printer demo with: ```sh cargo build --manifest-path demos/printerdemo_mcu/Cargo.toml --no-default-features --features=mcu-board-support/pico-st7789 --target=thumbv6m-none-eabi --release ``` The resulting file can be flashed with [elf2uf2-rs](https://github.com/jonil/elf2uf2-rs). Install it using: ```sh cargo install elf2uf2-rs ``` Now power off the Pico and connect it while holding down the "bootsel" button. The device will show up as a storage device with the name `RPI-RP2`. Then flash the demo to the Pico with: ```sh elf2uf2-rs -d target/thumbv6m-none-eabi/release/printerdemo_mcu ``` When the flashing completes the Pico will reboot and show the Slint Printer demo. The Mac will warn the drive was unmounted unexpectedly. This is expected and can be ignored. Now power off the Pico and connect it while holding down the "bootsel" button. The device will show up as a storage device. Mount the device: ```sh udisksctl mount -b /dev/sda1 ``` Then flash the demo to the Pico with: ```sh elf2uf2-rs -d target/thumbv6m-none-eabi/release/printerdemo_mcu ``` #### On the Raspberry Pi Pico2 Build the Slint Printer demo with: ```sh cargo build --manifest-path demos/printerdemo_mcu/Cargo.toml --no-default-features --features=mcu-board-support/pico2-st7789 --target=thumbv8m.main-none-eabihf --release ``` The resulting file can be flashed conveniently with [picotool](https://github.com/raspberrypi/picotool). You should build it from source. Then upload the demo to the Raspberry Pi Pico: push the "bootsel" white button on the device while connecting the micro-usb cable to the device, this connects some USB storage on your workstation where you can store the binary. Or from the command on linux (connect the device while pressing the "bootsel" button): ```sh # If you're on Linux: mount the device udisksctl mount -b /dev/sda1 # upload picotool load -u -v -x -t elf target/thumbv8m.main-none-eabihf/release/printerdemo_mcu ``` #### Using probe-rs This requires [probe-rs](https://probe.rs) and to connect the pico via a probe (for example another pico running the probe). Then you can simply run with `cargo run` ```sh CARGO_TARGET_THUMBV6M_NONE_EABI_LINKER="flip-link" CARGO_TARGET_THUMBV6M_NONE_EABI_RUNNER="probe-rs run --chip RP2040" cargo run --manifest-path demos/printerdemo_mcu/Cargo.toml --no-default-features --features=mcu-board-support/pico-st7789 --target=thumbv6m-none-eabi --release ``` #### Flashing and Debugging the Pico with `probe-rs`'s VSCode Plugin Install `probe-rs-debugger` and the VSCode plugin as described [here](https://probe.rs/docs/tools/vscode/). Add this build task to your `.vscode/tasks.json`: ```json { "version": "2.0.0", "tasks": [ { "type": "cargo", "command": "build", "args": [ "--manifest-path=demos/printerdemo_mcu/Cargo.toml", "--features=mcu-pico-st7789", "--target=thumbv6m-none-eabi", "--profile=release-with-debug" ], "problemMatcher": [ "$rustc" ], "group": "build", "label": "build mcu demo for pico" }, ] } ``` The `release-with-debug` profile is needed, because the debug build does not fit into flash. You can define it like this in the `demos/Cargo.toml` workspace manifest: ```toml [profile.release-with-debug] inherits = "release" debug = true ``` Now you can add the launch configuration to `.vscode/launch.json`: ```json { "version": "0.2.0", "configurations": [ { "preLaunchTask": "build mcu demo for pico", "type": "probe-rs-debug", "request": "launch", "name": "Flash and Debug MCU Demo", "cwd": "${workspaceFolder}", "connectUnderReset": false, "chip": "RP2040", "flashingConfig": { "flashingEnabled": true, "resetAfterFlashing": true, "haltAfterReset": true }, "coreConfigs": [ { "coreIndex": 0, "rttEnabled": true, "programBinary": "./target/thumbv6m-none-eabi/release-with-debug/printerdemo_mcu" } ] }, ] } ``` This was tested using a second Raspberry Pi Pico programmed as a probe with [DapperMime](https://github.com/majbthrd/DapperMime). ## Other Platforms [Contact us](https://slint.dev/contact) if you want to use Slint on other platforms/versions.