slint.dev

Slint is a declarative GUI toolkit for Rust, C++, JavaScript, and Python, and its own site shows it being used in commercial products — including OTIV autonomous rail vehicles, a WesAudio digital audio workstation plugin, an SK Signet EV charger HMI, and the Aava convolution plugin. Each of those customer entries on slint.dev carries a "Proprietary License" label, which tells you that shipping a closed-source commercial product on Slint is an accepted, documented use. What the site does not publish is a price list or a self-service checkout, so the practical answer for a commercial team is: commercial use is supported, but the exact terms depend on your product, and you confirm them with the Slint team rather than from a public pricing page.

What the "Proprietary License" label means

On slint.dev, the "Proprietary License" tag appears next to customer product pages, not as a general statement about the toolkit. Read it as a signal about how that customer ships Slint, not as the only license available to you:

• It indicates the customer distributes a closed-source product built with Slint.
• It implies a commercial arrangement exists between that customer and Slint, separate from any open-source license.
• It does not tell you the price, the seat count, the royalty structure, or whether support is bundled.

Because the label is attached per customer, you cannot infer your own terms from it. Treat it as evidence that the commercial path is real and in production, then get your own terms in writing.

The two-track model you should assume

The page evidence supports a dual-licensing pattern rather than a single license:

The important consequence: if your product can satisfy the open-source license conditions, you may not need a commercial agreement at all. If it cannot — for example, you ship a closed-source plugin, charger HMI, or vehicle UI — the commercial track is the one the customer examples point to.

What to confirm before you ship

The site gives you no pricing signals, no payment platform, and no license comparison table, so these are the questions to settle with Slint directly. Frame them around your actual product:

1. Distribution model — are you shipping a binary, a library linked into someone else's product, or a hosted service? Each can fall under different terms.
2. Closed vs. open source — will your Slint-based UI code be published, or kept proprietary?
3. Target platforms — embedded, desktop, mobile, or web. The site markets one codebase across these, but confirm your specific targets are covered.
4. Support and updates — the customer quotes emphasize responsiveness and support; check whether that is part of the commercial agreement or a separate item.
5. Volume and product count — one product or a family of products, and how many devices or seats.

How to get the right license

There is no pricing page or checkout flow on slint.dev, so the route is direct contact:

• Start from the Slint site and use its contact or sales channel to describe your product.
• Bring the answers to the five questions above; a specific description gets you a specific quote faster than a generic inquiry.
• Ask explicitly which license applies to your case and request the terms in writing before you commit engineering time.
• If you are evaluating first, the demos and the customer product pages show what the toolkit does in production — use them to judge fit, then negotiate terms.

The short version: Slint supports commercial, closed-source products, and its own site names four companies doing exactly that under a proprietary license. It does not publish prices or terms, so the licensing decision is a conversation with Slint, not a download-and-go step.

Yes. Slint is a declarative GUI toolkit that targets embedded, desktop, and web from a single codebase, and it supports Rust, C++, JavaScript, and Python. That combination is the core reason teams evaluating it for cross-platform work tend to shortlist it: you write the UI once in a declarative language and bind it to whichever host language and platform you are shipping on. The practical caveat is that "one codebase" covers the UI layer and its bindings, not your entire application — platform-specific drivers, OS integration, and deployment packaging still differ per target.

What Slint actually is

Slint is a declarative UI toolkit. You describe the interface in a .slint markup file — elements, layout, properties, and logic hooks — and the toolkit compiles that into native UI for the target platform. The host application logic lives in Rust, C++, JavaScript, or Python, and calls into the generated UI code.

The site frames this as "Design to Deploy" and "Seamlessly build elegant modern stylish native elegant GUIs for Embedded, Desktop, and Mobile." The current release referenced on the page is Slint 1.18.

Two properties matter most for the cross-platform question:

• Declarative UI definition. The interface is described once, separately from the host language, so the same markup can be reused across targets.
• Native rendering. The site describes the output as native GUIs, which is what makes it viable on embedded hardware where a browser engine is not an option.

Which targets and languages are covered

The four host languages are the important detail for mixed teams. A firmware team working in C++ and a tooling team working in Python can share the same UI definition rather than maintaining two divergent interfaces.

Why embedded is the harder case, and how Slint addresses it

Desktop and web targets generally have generous CPU, memory, and GPU budgets. Embedded targets do not. A toolkit that only works by embedding a browser engine will struggle on a device with limited RAM and no full compositor.

Slint's positioning on the site is explicitly embedded-first: the customer stories are industrial and device-level, not web dashboards. That is a meaningful signal, because it means the toolkit was designed around constrained rendering rather than adapted to it.

When evaluating for your own embedded project, check these against your hardware rather than assuming:

• Display resolution and scaling. The SK Signet case is directly relevant here — their HMI "scales to both 15-inch and 32-inch touch displays" installed on EV chargers. That is a real example of one interface definition serving two very different panel sizes.
• Touch input. Charger HMIs and vehicle interfaces are touch-driven; confirm your input stack is supported.
• Rendering backend. Match the backend to what your SoC actually provides.
• Memory ceiling. This is the constraint most likely to disqualify a toolkit, so measure it early with a representative screen rather than a hello-world.

What the production cases show

The site's #MadeWithSlint section lists shipping products across several device categories, which is more useful than a feature list for judging fit:

• OTIV autonomous rail vehicles. OTIV builds assisted, remote, and autonomous driving technology for rail. Co-founder Sam De Smet describes Slint as "an exceptional partner," citing "high-performance UI solutions." The relevant takeaway is safety-critical industrial UI on moving vehicles.
• WesAudio digital audio workstation plugin. WesAudio redesigned their DAW plugin UIs with Slint. CEO Michał Węglicki highlights "extensive out-of-the-box platform support" for cross-platform development. Audio plugins are a demanding case because they must run inside multiple host applications across operating systems.
• SK Signet EV charger HMI. The U.S. EV charging provider launched an HMI scaling across 15-inch and 32-inch touch displays. Manager Sang-Baek Lee cites "flexibility, high performance and value-for-money."
• Aava convolution plugin. Creator Jussi Viira calls Slint "a mature, production-ready UI solution" and notes the team is responsive, with issues and requested features "usually getting solved really quickly."

Across these, the pattern is consistent: one UI definition, several hardware or host configurations, and a preference for native performance over web technology. Note that the product pages for OTIV, WesAudio, and SK Signet are each marked "Proprietary License" — that label applies to those customers' products, not to Slint's own licensing, which the page does not specify.

How to decide for your project

Choose Slint when:

• You need the same interface on embedded hardware and on desktop or web, and you do not want to maintain separate UI implementations.
• Your team is split across Rust, C++, JavaScript, or Python and you want a shared UI layer.
• You are building a device HMI — charger, instrument, vehicle interface, plugin — where native rendering and predictable resource use matter more than access to the full web ecosystem.
• Your interface must scale across different display sizes from one definition, as in the SK Signet case.

Look elsewhere when:

• Your UI depends heavily on web-only libraries, browser APIs, or a DOM-based workflow.
• You need a large ecosystem of pre-built web components rather than a declarative markup language.
• Your team has no appetite for learning a declarative UI syntax alongside the host language.

Verifying fit before committing

1. Pick your hardest target first. If embedded is the constraint, prototype there, not on desktop. A desktop prototype tells you nothing about your memory ceiling.
2. Build one representative screen, not a demo — include your worst-case layout, your real font sizes, and your actual touch targets.
3. Measure on target hardware. Check memory footprint and frame behavior under your real display resolution.
4. Confirm your host language binding is the one you will actually ship with, and that your build pipeline produces the artifact your device needs.
5. Check the release you are targeting. The site references Slint 1.18; pin a version and read its notes rather than tracking the latest.

The single-codebase claim holds for the UI layer. Plan for the platform-specific work around it — drivers, packaging, and OS integration — as separate tasks, and the cross-platform promise is realistic rather than aspirational.

Slint is used in production by companies across embedded, desktop, and professional audio domains. The official site's #MadeWithSlint section names four concrete products: OTIV autonomous rail vehicles, WesAudio's digital audio workstation (DAW) plugin, SK Signet electric vehicle chargers, and the Aava convolution plugin. Each case is a shipped or launched product, and each is listed with a proprietary license, which makes them useful reference points if you are judging whether Slint is production-ready for your own project.

The four featured cases

OTIV — autonomous rail vehicles

OTIV builds technology for assisted, remote, and autonomous rail driving, aimed at industrial companies, railway undertakings, infrastructure managers, and OEMs. Co-founder Sam De Smet states that "safe, reliable, and intuitive user interfaces are critical for our customers," and describes Slint as "an exceptional partner" providing "high-performance UI solutions." The relevant signal here is the safety- and reliability-sensitive context: rail automation is not a casual consumer app, so a UI toolkit used there is being trusted in a demanding operational setting.

WesAudio — digital audio workstation plugin

WesAudio, a professional audio equipment manufacturer, adopted Slint for a complete redesign of its DAW plugin user interfaces. CEO Michał Węglicki highlights "extensive out-of-the-box platform support, making it a prime choice for cross-platform development," and adds that the support and willingness to help were "more than extraordinary." The site links both a live preview and a customer journey write-up for this case, so you can inspect the actual UI rather than rely on the quote alone.

SK Signet — electric vehicle charger HMI

SK Signet, described as the No. 1 EV charging solutions provider in the U.S., launched a new HMI that scales to both 15-inch and 32-inch touch displays on its chargers. Manager Sang-Baek Lee cites "flexibility, high performance and value-for-money along with great support." The scaling detail is the concrete engineering point: one HMI codebase covering two very different display sizes is exactly the kind of constraint embedded teams face.

Aava — convolution plugin

Aava is a convolution plugin that lets users adjust IR parameters. Creator Jussi Viira calls Slint "a mature, production-ready UI solution and a joy to work with," and notes that issues, bugs, and even requested features "usually get solved really quickly." This is the most direct production-readiness claim among the four quotes.

What these cases tell you if you're evaluating Slint

• Domain spread: the cases cover industrial/embedded (OTIV, SK Signet) and desktop audio tooling (WesAudio, Aava). If your product sits in one of those areas, you have a close comparable.
• Display and platform variety: the SK Signet case shows a single HMI spanning 15-inch and 32-inch touch displays; the WesAudio case emphasizes cross-platform support. Together they speak to the "one codebase, multiple targets" claim.
• Recurring themes in customer quotes: performance, cross-platform/platform support, and responsive support appear across multiple cases rather than in just one testimonial.
• Licensing context: all four products are listed with a proprietary license, so these are commercial deployments, not hobby projects.

How to use this as evidence

Treat the case list as a starting point, not a guarantee. The quotes are vendor-published testimonials, so they tell you who chose Slint and what they valued — not independently benchmarked performance. To make a decision:

1. Open the linked product pages and the WesAudio customer journey to see the interfaces in context.
2. Match your own constraints (display sizes, target platforms, embedded vs. desktop) against the closest case above.
3. If your situation resembles SK Signet's scaling requirement or WesAudio's cross-platform requirement, those are the two cases to study first.

If none of the four domains matches your project, the case list still answers the narrower question — Slint is used in shipped commercial products — but you will need to validate fit on your own targets.

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

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.

Slint is a declarative GUI toolkit for Rust, C++, JavaScript, and Python that lets you build native user interfaces for embedded, desktop, and web targets from a single codebase. It fits teams that want one UI definition reused across resource-constrained devices and full desktop or mobile apps, and that prefer a declarative syntax over hand-written imperative UI code. If you only need a quick web-only UI in a single language, a browser-native framework may be simpler; Slint's value shows up when native performance and cross-target reuse matter.

What "declarative GUI toolkit" means here

You describe the interface — layout, properties, states, and how elements relate — and the toolkit handles rendering and the underlying native widgets or drawing. The same UI description is compiled for each supported language binding and target, so the UI logic is not rewritten per platform.

The practical effect: UI structure lives in one place, while application logic stays in your chosen host language (Rust, C++, JavaScript, or Python). This is the "single codebase" claim on the site — one UI definition, multiple deployment targets.

What you can build with it

The site groups targets as Embedded, Desktop, and Mobile, and the customer examples show the range in production:

Two patterns stand out from these cases:

• Scaling across display sizes — SK Signet's HMI scales to both 15-inch and 32-inch touch displays, which is the kind of layout flexibility a declarative system is meant to give you.
• Cross-platform reach — WesAudio's CEO cites "extensive out-of-the-box platform support" as the reason for choosing Slint for a cross-platform plugin redesign.

So the realistic answer to "what can you build" is: embedded device HMIs (chargers, industrial equipment, vehicles), desktop applications, audio/plugin interfaces, and mobile UIs — anywhere you want native rendering and one UI source.

When Slint is a good fit

Choose it when several of these are true:

• You need the same UI on embedded hardware and desktop/mobile, and don't want to maintain separate UI code.
• You want native performance rather than a web view wrapper.
• Your team already works in Rust, C++, JavaScript, or Python and wants to stay in that language.
• You need a UI that adapts to different screen sizes (e.g., 15-inch and 32-inch panels).

Consider alternatives when:

• You only target the browser and want the largest ecosystem of web components.
• You need a UI toolkit tied to a single language's ecosystem rather than a cross-language one.

Getting started

The site's primary entry points are Get Slint and See Demos, and the current release referenced is Slint 1.18. The customer pages include Open Live Preview and Read Customer Journey links, which are useful for seeing real interfaces before committing.

A reasonable first step: pick your host language, open a demo, and check whether the declarative UI model matches how your team thinks about layout. The customer journeys (OTIV, WesAudio, SK Signet) are the most concrete evidence of what production use looks like.

A note on licensing and pricing

The customer product pages are labeled Proprietary License, indicating commercial licensing is part of how Slint is used in those products. The provided site material does not include pricing figures or a pricing page, so cost and license terms should be confirmed directly with Slint rather than assumed.