Which programming languages does Slint support for building user interfaces?

Updated

Slint officially supports four languages for building user interfaces: Rust, C++, JavaScript, and Python. You write the UI once in Slint's declarative .slint markup, then connect it to application logic in whichever of these languages your project already uses. If your stack is one of these four, you can adopt Slint without switching languages; if it isn't, there is no official binding for you to use.

The four supported languages

Language How you use it Typical fit
Rust Native Rust API, compiled into your binary Systems, embedded, performance-sensitive desktop tools
C++ Native C++ API Existing C++ codebases, embedded and desktop products
JavaScript JS binding for the UI layer Web-adjacent and Node-based tooling
Python Python binding Scripting, prototyping, internal tools

The key mechanism is separation: the .slint file describes layout, properties, and behavior hooks, and each language binding exposes that UI as an object your code can read from and write to. Because the UI definition is language-neutral, the same interface can be reused across bindings and across the platforms Slint targets — embedded, desktop, and mobile — from a single codebase.

How the bindings differ in practice

  • Rust and C++ are compiled languages, so the UI is built into the application binary. This is the path used in production products shown on the site, such as OTIV's rail automation interfaces and SK Signet's EV charger HMI, where performance and deployment on fixed hardware matter.
  • JavaScript and Python are typically used where faster iteration or integration with an existing runtime is more important than a fully compiled binary.
  • The declarative layer stays the same across all four, so moving a UI from one binding to another does not mean rewriting the interface definition — only the glue code that connects it to your logic.

Choosing a binding for your project

Pick the binding that matches the language your application logic is already written in:

  • Existing Rust or C++ codebase → use the matching native binding; you get a compiled UI with no extra runtime layer.
  • Python tooling or scripts → use the Python binding to add a native UI without leaving Python.
  • JavaScript environment → use the JS binding when your surrounding stack is JS-based.
  • Cross-platform product with mixed teams → the shared .slint UI can be maintained once while different parts of the product use different bindings.

If your project uses a language outside these four, Slint is not a fit unless you are willing to introduce one of them for the UI layer.

Where to start

The site's "Get Slint" entry point and its demos are the practical starting places: check the demo that matches your target platform, then follow the binding for your language. The customer examples — OTIV (rail), WesAudio (audio plugin UIs), SK Signet (EV charger HMI), and Aava (convolution plugin) — all illustrate the same pattern: a declarative UI connected to logic in a supported language, deployed to embedded or desktop targets.