mrkeyoor.com_
Tue 01 Sept 17:41 UTC
Dev Toolsevaluationupdated 23 Aug 2026

slint review

Slint is a declarative GUI toolkit for native applications on embedded hardware, desktop systems, mobile devices, and the web. Developers describe the interface in Slint's own markup language, then connect it to business logic written in Rust, C++, JavaScript, or Python.

+65stars / 7d
Verdict

Slint is one of the strongest open-source choices for a team that needs the same native UI model across Rust or C++, desktop, and constrained devices. The stable 1.x core, renderer choices, tooling, and active releases justify a serious prototype. JavaScript and Python users should accept beta bindings, while proprietary embedded teams must settle licensing before committing.

We ran it

Lab card: what happened when we ran slintScreenshot of slint (slint.dev)
Install✓ · 37s1 packages · 952 MB
Buildn/ano build script
Testsn/ano test script
Repo4756 files~355,829 lines of source · 36.4 MB · 34 CI workflows · tests dir

Answers from our run

Does slint build from source?

Dependencies installed in 37 seconds (1 packages), and the project has no separate build step. We cloned commit c1ef953 into a clean Debian container with 3 CPUs and no project-specific setup.

Does slint have tests you can run?

Not through a standard command: the project exposes no test script or target that our harness could run.

Who should not use slint?

Proprietary embedded products without budget or approval for a commercial license: the free royalty-free license excludes embedded systems.

What are the alternatives to slint?

Iced, egui, GTK 4 Rust bindings. Slint is one of the strongest open-source choices for a team that needs the same native UI model across Rust or C++, desktop, and constrained devices.

Setup2/5Templates help, but native targets and source builds need real tooling
Docs5/5Detailed language, platform, renderer, build, API, and license guides
Community5/5Active August 2026 pushes, issue work, discussions, and releases
Maturity5/5Stable 1.x core with years of releases and multiple production bindings

Discussed on

  1. hnSlint GUI Toolkit139 points
  2. hnSlint: Native GUI Toolkit for Rust, C++ or JavaScript112 points
  3. hnSixtyFPS Becomes Slint92 points
  4. hnPorting the Slint UI Toolkit to a Microcontroller with 264K RAM91 points
  5. hnSlint Matures to 1.065 points

Who it’s for

Rust or C++ teams building one native interface across desktop and embedded targets.
Device makers that need a software renderer as well as GPU-backed options.
Product teams that want UI markup separated from application logic.
Developers who value live preview, an LSP, editor support, and stable 1.x APIs.

Who it’s NOT for

Proprietary embedded products without budget or approval for a commercial license: the free royalty-free license excludes embedded systems.
JavaScript or Python teams requiring a stable binding: both integrations are labeled beta, and the Node guide says APIs will change.
Teams unwilling to learn a dedicated .slint language and compiler workflow.
Linux contributors expecting a pure language-level setup: the build guide lists Rust plus xcb, xkbcommon, fontconfig, OpenSSL, and optional renderer or media dependencies.
Applications that depend on flawless wrapped table text or Windows native-menu cleanup today: both have current open bug reports.

Setup reality

Our Node 22 sandbox installed the pnpm workspace in 37 seconds. The measured install recorded 1 package and used 952 MB. There was no build script or target in that Node entry point, so we skipped the build. There was also no test script or target, so we skipped tests. This did not exercise Slint's Rust, C++, Python, or native rendering paths.

A normal application also needs the toolchain for its chosen language and target. Building the repository centers on Rust 1.92 or newer. Linux development adds xcb, xkbcommon, fontconfig, and OpenSSL packages; C++ adds CMake, a C++20 compiler, and usually Ninja. The Node binding requires Node 20 or newer and ships prebuilt binaries only for listed platforms.

Renderer and platform choices change the setup. FemtoVG needs OpenGL ES, Skia has a defined set of binary targets, and the software renderer avoids GPU dependencies. Windows source checkouts need symbolic links enabled. Proprietary embedded use also requires a commercial license rather than the free royalty-free option.

A native toolkit with its own UI language

Slint separates interface description from application logic. Layout, visual elements, states, bindings, and callbacks live in .slint files. A compiler turns that markup into code for the selected language, while Rust, C++, JavaScript, or Python handles the rest of the application. The result can run on desktops, mobile devices, browsers through WebAssembly, or embedded hardware.

That separation is the main reason to consider it. A designer or UI engineer can work on the declarative layer while systems developers keep device access and business rules in their normal language. The markup is small enough to read, but it is another language to learn. Teams expecting JSX, QML, or native platform layout files cannot transfer code directly.

The core project says its 1.x APIs are stable. Rust and C++ are the established bindings; JavaScript and Python are explicitly beta. The Node guide warns that APIs will change and important features are still being developed. Choose the binding with that difference in mind rather than treating the four languages as equal surfaces.

Rendering spans GPUs and small devices

Slint can render through FemtoVG on OpenGL ES, Skia, or a CPU-only software backend. That range is useful when the same product family includes a desktop configuration tool and a dedicated device screen. Compile-time selection lets teams avoid shipping every backend and style. If Qt is present, Slint can use Qt's widget style for a more platform-native appearance.

The runtime stores component elements, properties, and related data in a compact region to reduce allocations. The compiler can optimize pure property expressions and generate native code. Those architectural choices suit embedded work, but they do not remove target-specific engineering. Input devices, graphics drivers, fonts, window systems, memory budgets, and cross-compilers still belong to the product team.

Tooling is better than the usual young domain-specific language. Slint has an LSP with completion and live preview, a VS Code extension, a standalone viewer with automatic reload, an online SlintPad editor, and a Figma import plugin. Separate templates exist for Rust, C++, Node.js, and Python.

What happened when we ran it

We cloned commit c1ef953 into an unprivileged Debian container with Node 22, 3 CPUs, 8 GB of RAM, and no secrets. The checkout contained 4,756 files, about 355,829 lines of source, and used 36.4 MB before installation.

The pnpm install succeeded in 37 seconds. Our harness recorded 1 installed package and 952 MB on disk. The selected Node workspace had no build script or target, so we skipped the build. It also had no test script or target, so we skipped tests.

Those results cover dependency setup for the measured Node entry point only. They do not show that the Rust compiler, C++ SDK, Python binding, examples, or any graphics backend built or ran in our container. The repository contains a tests directory, monorepo workspaces, and 34 CI workflow files, but our run produced no native build or test result that we can pass on. Buyers should not read a successful pnpm install as a toolkit qualification.

Source builds are platform work

The build guide requires Rust 1.92 or newer. Linux developers may need xcb, xkbcommon, fontconfig, and OpenSSL development packages. C++ work adds CMake 3.21 or newer, a C++20 compiler, and optionally Ninja. Windows needs the MSVC toolchain, and the repository's symbolic links require a correctly configured checkout. Media examples add FFmpeg or GStreamer.

Node 20 or newer is supported for consumers. Prebuilt Node binaries are listed for Linux on x86-64 and ARM64 with glibc, Apple Silicon macOS, and Windows on x86-64 or ARM64. Other platforms need a source build with pnpm, Rust, and the relevant native prerequisites. The source build of the current Node API needs a newer Node 22 release stated in the guide.

This is reasonable for a native toolkit, but it is far removed from installing a browser component package. Evaluate on the actual operating system, renderer, GPU, display server, and target board you intend to ship.

Licensing can decide the purchase

Slint's repository does not fit one standard SPDX label because the framework is offered under three choices. GPLv3 covers open-source applications, including embedded systems. A royalty-free license covers proprietary desktop, mobile, and web applications at no cost when its attribution requirement is met, but excludes embedded systems. Proprietary embedded products require the commercial license.

That boundary is easy to miss because embedded support is central to the technical pitch. A device manufacturer should involve whoever owns licensing before building a product around Slint. Documentation and examples use MIT, and individual third-party assets retain their own terms. The repository records file-level licensing through REUSE metadata.

Health and known limits

Version 1.17.1 was released on 2026-07-07 as a patch for bugs and crashes, with update instructions and prebuilt C++ SDKs and tools for several targets. The repository was pushed on 2026-08-23. Its 830 open issues and pull requests are a large queue, yet recent traffic covers renderer work, platform support, accessibility tests, language bindings, fixes, and new APIs. The dated push and issue activity show a busy project rather than one coasting on old releases.

Current bugs still matter. One Windows report traces a native-menu reference cycle that leaves a window adapter and GPU resources alive after shutdown. Another reproduces word-wrapped text overlapping the next row in box layouts and provides an explicit sizing workaround. A macOS request notes that Slint lacks an API for opening documents through Finder file associations. These are specific platform and layout gaps that should enter an application's acceptance tests.

Slint earns its place on a shortlist when cross-platform native UI and embedded reach outweigh the cost of a new markup language. Rust and C++ teams get the most settled path. Prototype the hardest target first, confirm the license, and test the renderer and widgets your product will actually ship.

Alternatives

ProjectWhat it isPick it when
IcedA Rust GUI library inspired by Elm with a message-driven application architecture.pick this instead when the whole application is Rust and you prefer Rust-native UI composition over a separate markup language.
eguiAn immediate-mode Rust GUI library suited to tools, editors, and interactive visual applications.pick this instead when rapid Rust UI code and an immediate-mode model fit better than compiled declarative markup.
GTK 4 Rust bindingsRust bindings for the mature GTK 4 desktop toolkit.pick this instead when Linux desktop integration and the GTK ecosystem matter more than embedded targets or one custom UI language.

What people are saying

  1. [github-trending] slint-ui/slint

Sources

  1. Slint README
  2. Slint build guide
  3. Slint licensing guide
  4. Slint Node.js binding guide
  5. Slint 1.17.1 release
  6. Wrapped text layout issue
  7. Native menu resource leak issue

More dev tools reviews

workmux · v2rayNG · SecLists · hashcat · eslint · fastfetch · the whole board →