Slint

Open source alternative to Qt

24.6K stars
Triple-licensed: Royalty-free 2.0 / GPL-3.0-only / Commercial (Slint)
Active this week
Last commit today

Last verified Nov 13, 2026

Build native UIs for Rust, C++, JavaScript, and Python from a single declarative codebase, targeting embedded, desktop, mobile, and web.

Visit website GitHub24.6K

Read the full breakdownWho it is for, how it works, trade-offs, the quick start and the FAQ

who it's for

Who Slint is for#

Embedded engineers building proprietary HMI on microcontrollers

Teams building human-machine interfaces on STM32, ESP32, or RP2040 devices in Rust or C++ can use Slint's `.slint` language for the UI layer with no runtime overhead. The 300KiB RAM footprint, bare-metal rendering, and hardware-accelerated rendering backends make Slint a fit for resource-constrained embedded targets.

Skip if:

Open-source embedded projects can use GPL-3.0 at no cost. Proprietary embedded products require the Commercial license; if your budget does not allow that, evaluate whether GPL-3.0 terms fit your project.

Cross-platform desktop developers in Rust

Rust developers building cross-platform desktop applications can reach for Slint's Rust crate (on crates.io) to add a native UI layer without leaving the Rust ecosystem or shipping Electron. The Royalty-free license covers proprietary desktop apps at no cost, with no per-seat fees.

Skip if:

If you need deep platform-native widget integration (macOS AppKit-style controls, Windows WinUI specifics) or a mature ecosystem of third-party Slint components, Qt or native platform frameworks may be closer to what you need today.

Teams migrating a Qt QML UI to Slint

Teams maintaining a Qt-based UI who want to drop Qt's commercial license cost or add Rust as a language can migrate incrementally. The `.slint` declarative model is conceptually similar to QML, and Jasic Technology reports that migrating from Qt QML "reduced or eliminated bugs, improved performance, and made it much easier to rapidly design the UI."

Skip if:

If your Qt codebase depends heavily on Qt's widget library, Qt Quick Controls, or Qt's graphics scene graph specifics, the migration effort may be substantial. Evaluate a proof of concept on a contained UI module first.

Audio and media tool developers needing a lightweight native UI

Developers building desktop audio plugins, DAW tools, or media applications who need a native, low-latency UI can use Slint. WesAudio documents a full DAW plugin UI redesign with Slint, and the Aava convolution plugin uses Slint in production. The Royalty-free license covers proprietary desktop apps at no cost.

Skip if:

If your audio plugin needs to run as a VST or AU plugin inside a host application rather than as a standalone window, verify Slint's plugin hosting compatibility before committing to it.

the problem

The problem it solves#

Building a native GUI that runs across embedded hardware, desktop operating systems, and web browsers normally means maintaining separate codebases or accepting platform-specific compromises. Qt has been the dominant choice for cross-platform native UIs, particularly in embedded systems, but its commercial licensing for embedded targets adds significant per-developer cost and ties teams to a C++ and QML development model.

The pain deepens for teams using Rust or Python: Qt bindings for those languages are third-party, unsupported by Qt's commercial model, and often lag the main toolkit's releases. JavaScript and Python teams building desktop tools face a similar challenge: Electron and similar web-based wrappers can run native-looking apps, but ship a full browser engine that is orders of magnitude heavier than a native toolkit. Teams that need to target microcontrollers find the gap even wider: a full web engine cannot run on a device with 256KiB of RAM.

how Slint solves it

How it solves it#

Declarative .slint markup language

UI is defined in `.slint` files, a domain-specific declarative language that separates UI design from business logic. The UI compiles ahead of time to native code, with property bindings that the compiler can inline and optimize. Designers and developers can work in parallel: the `.slint` layer has no dependency on the host language.

Four host language bindings

Connect business logic written in Rust, C++, JavaScript (Node.js, beta), or Python (beta) to the same `.slint` UI. Each language has its own API and getting-started template. The Rust crate is on crates.io; the Node.js package is `slint-ui` on npm; the Python package is `slint` on PyPI.

Embedded to web target coverage

The same codebase targets STM32, ESP32, and RP2040 microcontrollers, embedded Linux on Raspberry Pi, desktop on Windows, macOS and Linux, and browser via WebAssembly. The runtime fits in under 300KiB RAM for bare-metal embedded targets, with no OS requirement.

Live Preview and IDE tooling

An LSP server and VS Code extension provide auto-complete, live preview, code navigation, diagnostics, and syntax highlighting for `.slint` files. The Live Preview reloads in real time as you edit, with a data editor for testing interactions without recompiling. A Figma to Slint plugin lets designers export designs directly to `.slint` code.

Multiple rendering backends

Choose the graphics renderer at compile time: `femtovg` uses OpenGL ES 2.0, `skia` uses the Skia graphics engine for high-quality rendering, and `software` uses the CPU with no additional dependencies for devices without a GPU. Slint uses GPU acceleration, DMA2D, framebuffer, or line-by-line rendering depending on the hardware.

GUI test automation

Built-in support for UI testing lets you assert on component state and test interactions programmatically. Tests run directly in VS Code or integrate with a CI pipeline. The testing API covers property reads, event simulation, and screenshot-based verification, reducing regressions when modifying `.slint` UI files.

strengths · trade-offs

Strengths and trade-offs#

Strengths

Free for proprietary desktop, mobile, and web appsThe Royalty-free 2.0 license permits building and distributing proprietary desktop, mobile, and web applications at no cost, as long as the application discloses its use of Slint (for example via the AboutSlint widget). This covers internal commercial use, eliminating per-developer licensing fees for non-embedded targets.
Runtime fits in under 300KiB RAMThe Slint runtime uses a reactive property system and stores components in a single memory region to minimize allocations. The resulting footprint is small enough to run on STM32 and RP2040 microcontrollers, a size range where Qt and Electron are not viable options.
Separates UI design from language-specific business logicThe `.slint` declarative layer is independent of the host language. A single UI design file can be connected to Rust, C++, JavaScript, or Python without changes. This means designers can iterate on the `.slint` layer while engineers work on backend logic in their preferred language.
Stable 1.x API with active maintenanceSlint follows a stable 1.x release policy, with the project last pushed in November 2026 and 195 contributors on GitHub. The team explicitly commits to evolving without breaking existing code, which matters for embedded projects with long deployment cycles. Customer testimonials from production deployments in rail automation, EV chargers, and DAW plugins confirm production-readiness.

Trade-offs

-Proprietary embedded apps require the Commercial licenseProprietary applications targeting embedded systems require the Commercial license. Desktop, mobile, and web proprietary apps use the Royalty-free 2.0 license at no cost; open-source projects on any platform, including embedded, use GPL-3.0 at no cost. Only proprietary embedded products require the paid Commercial license. Teams building embedded products for commercial distribution should factor this in early.
-JavaScript and Python bindings are betaThe Node.js and Python APIs are marked beta in the README. They have getting-started templates and npm/PyPI packages, but may have missing features or API stability gaps compared to the mature Rust and C++ bindings. Teams relying on JavaScript or Python should test their specific use case before choosing Slint for production.
-Custom DSL requires dedicated onboardingSlint uses its own `.slint` markup language rather than a subset of an existing language. Teams fluent in QML, SwiftUI, or HTML/CSS will recognize the declarative pattern, but `.slint` syntax, the property binding model, and the component system have their own specifics. Budget time for onboarding even with prior declarative UI experience.
-588 open issuesThe GitHub repository has 588 open issues as of November 2026, excluding pull requests. For an actively maintained toolkit targeting a wide range of platforms and four host languages, this is not unusual, but teams with specific edge-case requirements should search the issue tracker before choosing Slint for a production deployment.

versus alternatives

Slint vs alternatives#

Slint vs Qt

Slint and Qt both target cross-platform native GUI development with embedded system support, but they differ substantially on licensing cost, language coverage, and runtime footprint.

Feature	Slint	Qt
License model	Royalty-free 2.0 / GPL-3.0 / Commercial	GPL / Commercial
Proprietary desktop, mobile, web	Free (Royalty-free 2.0)	Commercial license required
Proprietary embedded	Commercial license required	Commercial license required
Open source, all platforms	GPL-3.0, free	GPL, free
Host languages	Rust, C++, JavaScript (beta), Python (beta)	C++ and QML; third-party for other languages
Runtime footprint	Under 300KiB RAM	Significantly larger; not viable on MCUs
WebAssembly	Yes	Limited

For teams building proprietary desktop or mobile applications, Slint's Royalty-free license eliminates the per-developer commercial cost that Qt carries for proprietary use. Qt's commercial plans add per-developer annual fees that become a significant line item for smaller teams, while Slint's Royalty-free tier covers the same targets at no cost.

For proprietary embedded projects, both toolkits require a paid commercial license. Where Slint has a clear advantage is on constrained hardware: a 300KiB RAM runtime runs on STM32 and RP2040 microcontrollers where Qt cannot. Jasic Technology's engineering team reports that moving from Qt QML to Slint "reduced or eliminated bugs, improved performance, and made it much easier to rapidly design the UI."

Qt remains the better fit when: the project depends on Qt's mature widget library or Qt Quick Controls; the team has deep existing C++ and QML investment; Qt's certified hardware support or formal safety certifications are procurement requirements; or the larger Qt ecosystem of third-party components is a priority.

For Rust teams, teams targeting microcontrollers, or projects that want to eliminate commercial licensing costs for desktop and mobile targets, Slint is the stronger option.

install · quick start

Quick start#

bash

Install Slint by adding the package for your language using its package manager.

```bash
cargo add slint
npm install slint-ui
pip install slint
```

tech stack · detected from GitHub

What it's built on#

Languages: C++JavaScriptPythonRustTypeScript
Runtimes: WebAssembly
Tooling: esbuild

frequently asked

FAQ#

Is Slint free for commercial use?

It depends on your target platform. Desktop, mobile, and web applications can use the Royalty-free 2.0 license at no cost, including proprietary commercial products, as long as you disclose your use of Slint (for example via the included AboutSlint widget). Open-source projects on any platform, including embedded, can use the GPL-3.0 license at no cost. Proprietary embedded applications require the paid Commercial license, including commercial distribution of embedded products. Reselling Slint itself as a managed or hosted service also requires the Commercial license.

What is the .slint language?

.slint is Slint's declarative markup language for describing UI structure, layout, and appearance. Similar in concept to QML or SwiftUI, you define components, properties, bindings, and animations in .slint files, which compile ahead of time to native machine code. Business logic stays in your host language (Rust, C++, JavaScript, or Python) and communicates with the UI through a generated API. The .slint files are independent of the host language, so the same UI design can be connected to any supported language.

Which languages can I use with Slint?

Rust and C++ have stable, production-ready bindings. JavaScript (via Node.js) and Python bindings are available as beta packages on npm (slint-ui) and PyPI (slint). Each language has an official getting-started template on GitHub. The Rust crate is available on crates.io.

Does Slint work on microcontrollers without an operating system?

Yes. Slint targets microcontrollers including STM32, ESP32, and RP2040, with a runtime that fits in under 300KiB RAM. It runs on bare-metal targets as well as embedded Linux on devices like the Raspberry Pi. The rendering backend is configurable at compile time: a CPU-only software renderer is available for devices without a GPU, and hardware-accelerated paths (DMA2D, framebuffer rendering) are available for supported chips.

How does Slint compare to Qt for embedded development?

Both toolkits target embedded systems, but Qt requires a Commercial license for most proprietary embedded products and Slint does too for proprietary embedded. Where Slint differs: its runtime footprint is under 300KiB RAM, making it viable on microcontrollers like STM32 and RP2040 where Qt cannot run. Slint also adds Rust, Python, and JavaScript as first-class binding languages alongside C++, and its Royalty-free license covers desktop/mobile/web proprietary apps at no cost where Qt requires a commercial license.

also worth a look

Similar open-source tools#

BUI

InDeveloper Tools

Blender's widget system for Python, Rust, JavaScript and C apps

2,383 GitHub stars
Licence GPL-3.0

Opensource UI

Alternative toTailwind UI

200+ copy-paste React and Next.js components, MIT licensed, no package

837 GitHub stars
Licence MIT

OpenCreator

Alternative toHeyGen

Local AI workspace for video, image, voice, and translation

14,300 GitHub stars
Licence Apache-2.0

armorpaint

Alternative toAdobe Substance 3D Painter

Open source 3D PBR texture painting with GPU acceleration

5,478 GitHub stars
Licence zlib/libpng License

renodx

InDeveloper Tools

Game-specific HDR mods and shader replacement for DirectX titles

4,801 GitHub stars
Licence MIT

Renderdoc

Alternative toNVIDIA Nsight Graphics

Frame-capture graphics debugger for Vulkan, D3D, and OpenGL

11,304 GitHub stars
Licence MIT

by category

Open source tools in these categories#

633

Inbox Zero

Alternative toSuperhuman

AI email assistant that drafts replies and clears your inbox

12,987 GitHub stars
Licence AGPL-3.0
#Email

rakazo

Alternative toGrok Bot

AI teammates you own: your keys, your model, your machine.

7,869 GitHub stars
Licence Apache-2.0
#AI Agents

SnitchFeed

Live monitoring on LinkedIn, X, Reddit & more. Agentic social listening for startups.

Marketing & Growth

Advertise your product

The projects we add and every new guide. Free, unsubscribe any time.

Find open source alternatives to paid software

Slint vs Qt

Slint and Qt both target cross-platform native GUI development with embedded system support, but they differ substantially on licensing cost, language coverage, and runtime footprint.

Feature	Slint	Qt
License model	Royalty-free 2.0 / GPL-3.0 / Commercial	GPL / Commercial
Proprietary desktop, mobile, web	Free (Royalty-free 2.0)	Commercial license required
Proprietary embedded	Commercial license required	Commercial license required
Open source, all platforms	GPL-3.0, free	GPL, free
Host languages	Rust, C++, JavaScript (beta), Python (beta)	C++ and QML; third-party for other languages
Runtime footprint	Under 300KiB RAM	Significantly larger; not viable on MCUs
WebAssembly	Yes	Limited

For Rust teams, teams targeting microcontrollers, or projects that want to eliminate commercial licensing costs for desktop and mobile targets, Slint is the stronger option.

Who Slint is for#

Embedded engineers building proprietary HMI on microcontrollers

Skip if:

Cross-platform desktop developers in Rust

Skip if:

Teams migrating a Qt QML UI to Slint

Skip if:

Audio and media tool developers needing a lightweight native UI

Skip if:

The problem it solves#

How it solves it#

Declarative .slint markup language

Four host language bindings

Embedded to web target coverage

Live Preview and IDE tooling

Multiple rendering backends

GUI test automation

Strengths and trade-offs#

Strengths

Trade-offs

Slint vs alternatives#

Slint vs Qt

Quick start#

What it's built on#

FAQ#

Similar open-source tools#

Open source tools in these categories#

Developer Tools

Web & App Development

Design & Creative

Find open source alternatives to paid software

Who Slint is for#

Embedded engineers building proprietary HMI on microcontrollers

Skip if:

Cross-platform desktop developers in Rust

Skip if:

Teams migrating a Qt QML UI to Slint

Skip if:

Audio and media tool developers needing a lightweight native UI

Skip if:

The problem it solves#

How it solves it#

Declarative .slint markup language

Four host language bindings

Embedded to web target coverage

Live Preview and IDE tooling

Multiple rendering backends

GUI test automation

Strengths and trade-offs#

Strengths

Trade-offs

Slint vs alternatives#

Slint vs Qt

Quick start#

What it's built on#

FAQ#

Similar open-source tools#

Open source tools in these categories#

Developer Tools

Web & App Development

Design & Creative

Find open source alternatives to paid software