Skip to content
Slint Docs

Embedded

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

Section titled “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 ↗ for recipes.

Rust applications work out of the box with Yocto’s Rust support.

Microcontrollers

Section titled “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

#![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");
}
rust

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

[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" }
toml

In your build.rs, you must include a call to slint_build::print_rustc_flags().unwrap() to set some of the flags.

Espressif (ESP32)

Section titled “Espressif (ESP32)”

Prerequisites

Section titled “Prerequisites”

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

Section titled “ESP32-S3-Box-3”

To compile and run the Slint Printer demo:

Terminal window
CARGO_PROFILE_RELEASE_OPT_LEVEL=s cargo +esp run -p printerdemo_mcu --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
bash

ST (STM32)

Section titled “ST (STM32)”

Follow the steps below to run the Slint Printer Demo

STM32H735G-DK

Section titled “STM32H735G-DK”

Using probe-rs ↗.

Terminal window
CARGO_PROFILE_RELEASE_OPT_LEVEL=s CARGO_TARGET_THUMBV7EM_NONE_EABIHF_RUNNER="probe-rs run --chip STM32H735IGKx" cargo run -p printerdemo_mcu --no-default-features  --features=mcu-board-support/stm32h735g --target=thumbv7em-none-eabihf --release
bash

Raspberry Pi (Pico)

Section titled “Raspberry Pi (Pico)”

Only Rust programs are currently supported on the Raspberry Pi Pico.

On the Raspberry Pi Pico

Section titled “On the Raspberry Pi Pico”

Ensure the right target is set:

Terminal window
rustup target add thumbv6m-none-eabi
bash

Build the Slint Printer demo with:

Terminal window
cargo build -p printerdemo_mcu --no-default-features --features=mcu-board-support/pico-st7789 --target=thumbv6m-none-eabi --release
bash

The resulting file can be flashed with elf2uf2-rs ↗. Install it using:

Terminal window
cargo install elf2uf2-rs
bash

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:

Terminal window
elf2uf2-rs -d target/thumbv6m-none-eabi/release/printerdemo_mcu
bash

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.

On the Raspberry Pi Pico2

Section titled “On the Raspberry Pi Pico2”

Build the Slint Printer demo with:

Terminal window
cargo build -p printerdemo_mcu --no-default-features --features=mcu-board-support/pico2-st7789 --target=thumbv8m.main-none-eabihf --release
bash

The resulting file can be flashed conveniently with 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):

Terminal window
# 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
bash

Using probe-rs

Section titled “Using probe-rs”

This requires 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

Terminal window
CARGO_TARGET_THUMBV6M_NONE_EABI_LINKER="flip-link" CARGO_TARGET_THUMBV6M_NONE_EABI_RUNNER="probe-rs run --chip RP2040" cargo run -p printerdemo_mcu --no-default-features --features=mcu-board-support/pico-st7789 --target=thumbv6m-none-eabi --release
bash

Flashing and Debugging the Pico with probe-rs’s VSCode Plugin

Section titled “Flashing and Debugging the Pico with probe-rs’s VSCode Plugin”

Install probe-rs-debugger and the VSCode plugin as described here ↗.

Add this build task to your .vscode/tasks.json:

{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "cargo",
      "command": "build",
      "args": [
        "--package=printerdemo_mcu",
        "--features=mcu-pico-st7789",
        "--target=thumbv6m-none-eabi",
        "--profile=release-with-debug"
      ],
      "problemMatcher": [
        "$rustc"
      ],
      "group": "build",
      "label": "build mcu demo for pico"
    },
  ]
}
json

The release-with-debug profile is needed, because the debug build does not fit into flash.

You can define it like this in your top level Cargo.toml:

[profile.release-with-debug]
inherits = "release"
debug = true
toml

Now you can add the launch configuration to .vscode/launch.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"
                }
            ]
        },
    ]
}
json

This was tested using a second Raspberry Pi Pico programmed as a probe with DapperMime ↗.

Other Platforms

Section titled “Other Platforms”

Contact us ↗ if you want to use Slint on other platforms/versions.

© 2026 SixtyFPS GmbH