Get Started

A Slint application is a user interface written in .slint files, connected to business logic in Rust, C++, JavaScript, or Python. This page gets your machine ready for that: an editor that understands .slint, the toolchain for your language, and a project to start from.

Set Up Your Tools

Editor

Slint provides an editor extension that helps you write .slint code. It gives you syntax highlighting, completion, diagnostics, and a live preview of the UI as you type.

Install the Slint extension for Visual Studio Code, or see Manual Setup for other editors.

AI Coding Assistant (Optional)

If you already use an AI coding agent, the Slint skill teaches it the .slint language and lets it inspect your running application. See AI Coding Assistants for the install command of each tool.

Install the Prerequisites

Pick the language you want to write your application logic in.

Install Rust by following its getting-started guide ↗. Slint needs Rust 1.92 or newer; check with rustc --version.

The Slint crate builds as part of your project, so no separate installation of Slint is needed. The Rust API documentation describes how to add it to an existing project.

We also recommend rust-analyzer ↗ for Rust support in your editor.

A C++ compiler that supports C++20.
CMake ↗ 3.21 or newer.
Rust ↗, 1.92 or newer, to build Slint from source. The template below does this automatically with CMake’s FetchContent.

The C++ documentation has its own Set Up Development Environment page. It covers the pre-built Slint packages for Linux and Windows x86-64, which don’t need Rust, and how to use Slint from an existing CMake project.

Install Node.js ↗ 20 or newer, which includes npm.

The slint-ui package ships pre-built binaries for macOS, Windows, and Linux. See the Node.js documentation for platforms that need a build from source.

Python ↗ 3.12 or newer.
uv ↗ to manage the project and its dependencies.

The slint package ships pre-built binaries for macOS, Windows, and Linux. See the Python documentation for platforms that need a build from source.

Create a Project From a Template

Each language has a template repository with a minimal application that follows our recommended project structure.

In Visual Studio Code, open the command palette and run Slint: Create New Project from Template. It downloads the template for your language into a folder of your choice. See Visual Studio Code for a walk-through with screenshots.

Without VS Code, download the template by hand:

Download and extract the ZIP archive ↗ of the Rust template ↗.
Rename the extracted directory and change into it:
Terminal window
```
mv slint-rust-template-main my-project
cd my-project
```
bash
Build and run:
Terminal window
```
cargo run
```
bash

Edit the name field in Cargo.toml to match the name of your project.

Download and extract the ZIP archive ↗ of the C++ template ↗.
Rename the extracted directory and change into it:
Terminal window
```
mv slint-cpp-template-main my-project
cd my-project
```
bash
Configure and build with CMake:
Terminal window
```
cmake -B build
cmake --build build
```
bash
The first configure fetches and builds Slint from source, which takes a few minutes.
Run the application on Linux or macOS:
Terminal window
```
./build/my_application
```
bash
Or on Windows:
Terminal window
```
build\my_application.exe
```
bash

Download and extract the ZIP archive ↗ of the Node.js template ↗.
Rename the extracted directory and change into it:
Terminal window
```
mv slint-nodejs-template-main my-project
cd my-project
```
bash
Install the dependencies and run:
Terminal window
```
npm install
npm start
```
bash

Download and extract the ZIP archive ↗ of the Python template ↗.
Rename the extracted directory and change into it:
Terminal window
```
mv slint-python-template-main my-project
cd my-project
```
bash
Install the dependencies and run:
Terminal window
```
uv run main.py
```
bash

A window with a counter and a button appears. The UI lives in ui/app-window.slint; the file next to it in src/ (or main.py) holds the application logic.

Mobile and Embedded

The templates above build a desktop application. Slint also runs on phones and on embedded devices:

Android: see the project setup for Rust or C++.
iOS: see adding iOS support to a Rust application.
Embedded Linux and microcontrollers: the embedded guide shows how to run the demos on a board and how to set up a project for a microcontroller. The API documentation has more on microcontrollers for Rust and for C++ on ESP-IDF or STM32.

Next Steps

Open ui/app-window.slint in your editor and start the live preview. Changes to the file show up in the preview as you type, without rebuilding.
Follow the tutorial to build a complete application.
Read about the Slint language and its reactivity model.
Browse the language integrations for the API of your language.