Making Slint Desktop-Ready

Slint is a UI framework designed to be lean, modern, and cross-platform. Over the last five years, it has become the preferred option for building GUIs and HMIs for embedded systems, especially with Rust-based applications. When it comes to desktop development, commercial applications such as WesAudio have been built with Slint but we often encounter questions or concerns about whether Slint is a viable option for creating full-featured desktop applications.

We're excited to share that for the next few weeks we will be focused on improving features in Slint to make it production-ready for desktop application development. We are working together with the LibrePCB project in their quest to release their version 2.0, transitioning their Qt-based GUI to a Slint-based GUI.

The Upcoming Feature Set

1. Rich Text Support in Text Elements

Rich text support for Text elements will include the following features:

• Style: Bold, Italic, Underline
• Text colors
• Hyperlinks
• Unordered/ordered lists

We're looking at markdown as the markup language for creating the formatted text.

📌 Join the Discussion: #9560

2. Keyboard Shortcuts

Keyboard shortcuts make desktop applications more user-friendly, but Slint’s current support is limited.

As of Slint 1.13, you can capture key presses globally if you add a FocusScope around your window and handle the capture-key-pressed event yourself. In addition to this, we're going to add support for shortcuts in menus.

Here's how we want to improve this:

1. Add a new keyboard-shortcut builtin type: This type will let you define shortcuts declaratively using the @keys(...) macro:

   property <keyboard-shortcut> my_shortcut: @keys(Shift + Control + A);
   

   Slint will automatically handle platform differences — for example, mapping Ctrl to Cmd on macOS, and display the shortcut in a user-friendly way in menus and dialogs.

2. Shortcut support in MenuItem: Menu items will get a new shortcut property, so you can define actions and their shortcuts in one place:

   export MainWindow inherits Window {
       MenuBar {
           Menu {
               title: @tr("File");
               MenuItem {
                   title: @tr("Open");
                   shortcut: @keys(Ctrl + O);
                   activated => { /* Handle action */ }
               }
           }
       }
   }
   

This work is already in progress but we’d love your feedback: Do you like the proposed syntax? Are there other places where you’d like shortcut support beyond menus?

📌 Join the Discussion: #102

3. Global Drag & Drop

Drag and Drop allows users to grab an element with a pointer (e.g., mouse) and move it to a different location or application.

We’ve started laying the groundwork for this feature with experimental support for DragArea and DropArea. With these, you can already set up basic drag-and-drop interactions within the same window:

DragArea {
    // Can also be "application/x-my-app-foobar"
    mime-type: "text/plain";
    // Currently just text.
    data: "Hello World";
}

// ... Somewhere else ...
DropArea {
    can-drop(event) => { return true; }
    dropped(event) => { /* Handle drop */ };
}

A drop event provides details like the mime type, data, and position:

struct DropEvent {
    /// The mime type of the data being dragged
    mime_type: string,
    /// The data being dragged
    data: string,
    /// The current mouse position in coordinates of the `DropArea` element
    position: point,
}

Currently, this works only within a single window and is gated behind the experimental feature flag (SLINT_ENABLE_EXPERIMENTAL_FEATURES=1).

What’s next?

We plan to:

• Review and refine the experimental API.
• Add visual feedback for dragging, such as custom cursors or drag images.
• Support multiple mime types and data formats.
• Enable cross-window and cross-application drag and drop by extending the underlying platform APIs.
• Contribute upstream to winit, the community-driven windowing library Slint uses, so this works reliably across all platforms.

📌 Join the Discussion: #1967

4. Modal Windows / Dialogs

Modal windows are essential for building desktop applications, think of dialogs, alerts, or confirmation popups that temporarily block interaction with the rest of the application.

We’re adding a new API to make this easy:

// Modal to a window
confirm_dialog.window().show_modal(slint::WindowModality::Window(main_window.window()));

// Or modal to the application
confirm_dialog.window().show_modal(slint::WindowModality::Application));

And a similar API for other languages.

This API is already available in a pull request, but making it fully functional requires work on the underlying winit backend. Either we'll have to contribute modal support to winit or we’ll need to use platform APIs.

📌 Join the Discussion: #6607

5. Popup Window Improvements

Popup window support is pretty basic in Slint right now. Often they're not real windows but are rendered within the main window. We want to make popups real windows, known to the windowing system. This includes:

• Positioning API mapped to Wayland popup protocol
• Event forwarding semantics (e.g., hover events beneath a popup)
• Implementation for all major platforms (Win/Mac/Wayland/X11)
• Better default rendering (closing behavior, background, border, etc.)

📌 Join the Discussion: #1143 and #6000

6. Tooltips

Tooltips provide helpful context when users hover over buttons, icons, or other interface elements. We want to make them easy to use for both simple text tips and fully customized content.

Our goal is to support:

• Native-looking text tooltips: for a consistent look and feel across platforms.
• Fully customizable tooltips: so developers can design tooltips with custom components, or even interactive elements.

To achieve this, we may need to extend winit to provide native tooltip support where possible.

We’d love feedback on the API design. What's the simplest way you’d like to declare a tooltip for both simple and complex cases?

📌 Join the Discussion: #6446

7. System Tray Support

Permit applications to set up system tray icons and context menus for it, on Wayland/X11 (via dbus, not xembed), macOS, and Windows.

Example:

export MyTray inherits SystemTray {
    icon: MyLogic.is_active ? @image-url("...");
    tooltip: "...";

    Menu {
        MenuItem { ... }
    }

    clicked(event) => { ... }
}

let my_tray = MyTray::new();
my_tray.on_clicked(...);

📌 Join the Discussion: #6053

8. Two-Way Bindings

Two-way bindings are a powerful synchronization mechanism when sharing data. However, there are two limitations that we aim to lift:

• Add support for two-way bindings to items in a model. This will remove the need for manual callbacks to write back to the model.
• Add support for two-way bindings to individual members of structs. This will eliminate the need to make full copies of data structures.

📌 Join the Discussion: #814 and #2013

Get Involved

We want to make Slint production-ready for desktop with your help. If any of the above features are missing for your project, please add your requirements, join the discussion, and share your viewpoints. You can also contribute in one of the following ways:

• Testing new features as they roll out and providing feedback.
• Contributing code or examples, even small demos go a long way.
• Shaping the APIs by sharing what works and what doesn’t.
• Showcasing your apps and inspiring others by building with Slint.

Confused about Slint Licenses?

We often get questions about Slint’s licensing, so let’s make it simple.

Slint is available under three licenses:

To summarize, if you’re building desktop, mobile, or web applications, Slint is completely free for both open-source and proprietary projects when using either the GPLv3 or Royalty-Free License. The only time licensing matters is when you distribute the binary of your application. With GPLv3, the binary must also be distributed under GPLv3, while with the Royalty-Free License, you just need to attribute Slint.

Getting Support

Irrespective of which license you choose to use, you can always get support. Please post on Slint GitHub Discussions, or create a GitHub Issue, or post on our Mattermost chat to get support from the Slint community.

If require dedicated support or if it is time critical, you can purchase Premium Support.

🌟 Thanks

Big thanks to NGI0 Commons and NLNet for supporting the Slintify LibrePCB 2.0 project.