Skip to main content

Slint Python integration

Project description

Slint-python (Alpha)

Slint is a UI toolkit that supports different programming languages. Slint-python is the integration with Python.

Warning: Alpha Slint-python is still in the very early stages of development: APIs will change and important features are still being developed, the project is overall incomplete.

You can track the overall progress for the Python integration by looking at python-labelled issues at .

Slint Language Manual

The Slint Language Documentation covers the Slint UI description language in detail.



Slint can be installed with pip from the Python Package Index:

pip install slint

The installation will use binaries provided vi macOS, Windows, and Linux for various architectures. If your target platform is not covered by binaries, pip will automatically build Slint from source. If that happens, you need common software development tools on your machine, as well as Rust.

Building from Source

Try it out

If you want to just play with this, you can try running our Python port of the printer demo:

cd examples/printerdemo/python
pipenv update
pipenv run python

Quick Start

  1. Add Slint Python Package Index to your Python project: pipenv install slint
  2. Create a file called appwindow.slint:
import { Button, VerticalBox } from "std-widgets.slint";

export component AppWindow inherits Window {
    in-out property<int> counter: 42;
    callback request-increase-value();
    VerticalBox {
        Text {
            text: "Counter: \{root.counter}";
        Button {
            text: "Increase value";
            clicked => {
  1. Create a file called
import slint

# slint.loader will look in `sys.path` for `appwindow.slint`.
class App(slint.loader.appwindow.AppWindow):
    def request_increase_value(self):
        self.counter = self.counter + 1

app = App()
  1. Run it with pipenv run python

API Overview

Instantiating a Component

The following example shows how to instantiate a Slint component in Python:


export component MainWindow inherits Window {
    callback clicked <=> i-touch-area.clicked;

    in property <int> counter;

    width: 400px;
    height: 200px;

    i-touch-area := TouchArea {}

The exported component is exposed as a Python class. To access this class, you have two options:

  1. Call slint.load_file("app.slint"). The returned object is a namespace, that provides the MainWindow class:

    import slint
    components = slint.load_file("app.slint")
    main_window = components.MainWindow()
  2. Use Slint's auto-loader, which lazily loads .slint files from sys.path:

    import slint
    # Look for for `app.slint` in `sys.path`:
    main_window =

    Any attribute lookup in slint.loader is searched for in sys.path. If a directory with the name exists, it is returned as a loader object, and subsequent attribute lookups follow the same logic. If the name matches a file with the .slint extension, it is automatically loaded with load_file and the namespace is returned.

Accessing Properties

Properties declared as out or in-out in .slint files are visible as properties on the component instance.

main_window.counter = 42

Accessing Globals

Global Singletons are accessible in Python as properties in the component instance:

export global PrinterJobQueue {
    in-out property <int> job-count;
print("job count:", instance.PrinterJobQueue.job_count)

Setting and Invoking Callbacks

Callbacks declared in .slint files are visible as callable properties on the component instance. Invoke them as function to invoke the callback, and assign Python callables to set the callback handler.

Callbacks in Slint can be defined using the callback keyword and can be connected to a callback of an other component using the <=> syntax.


export component MyComponent inherits Window {
    callback clicked <=> i-touch-area.clicked;

    width: 400px;
    height: 200px;

    i-touch-area := TouchArea {}

The callbacks in Slint are exposed as properties and that can be called as a function.

import slint
import MyComponent from my_component_slint

component = MyComponent()
# connect to a callback

def clicked():

component.clicked = clicked
// invoke a callback

Another way to set callbacks is to sub-class and use the @slint.callback decorator:

import slint
import my_component_slint

class Component(my_component_slint.MyComponent):
    def clicked(self):

component = Component()

The @slint.callback() decorator accepts a name named argument, when the name of the method does not match the name of the callback in the .slint file. Similarly, a global_name argument can be used to bind a method to a callback in a global singleton.

Type Mappings

The types used for properties in the Slint Language each translate to specific types in Python. The follow table summarizes the entire mapping:

.slint Type Python Type Notes
int int
float float
string str
color slint.Color
brush slint.Brush
image slint.Image
length float
physical_length float
duration float The number of milliseconds
angle float The angle in degrees
structure dict Structures are mapped to Python dictionaries where each structure field is an item.
array slint.Model

Arrays and Models

Array properties can be set from Python by passing subclasses of slint.Model.

Use the slint.ListModel class to construct a model from an iterable.

component.model = slint.ListModel([1, 2, 3]);
del component.model[0]

When sub-classing slint.Model, provide the following methods:

    def row_count(self):
        """Return the number of rows in your model"""

    def row_data(self, row):
        """Return data at specified row"""

    def set_row_data(self, row, data):
        """For read-write models, store data in the given row. When done call set.notify_row_changed:"

When adding/inserting rows, call notify_row_added(row, count) on the super class. Similarly, removal requires notifying Slint by calling notify_row_removed(row, count).

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

slint-1.6.0a8.tar.gz (1.8 MB view hashes)

Uploaded Source

Built Distributions

slint-1.6.0a8-cp310-abi3-win_amd64.whl (3.2 MB view hashes)

Uploaded CPython 3.10+ Windows x86-64

slint-1.6.0a8-cp310-abi3-manylinux_2_35_x86_64.whl (5.9 MB view hashes)

Uploaded CPython 3.10+ manylinux: glibc 2.35+ x86-64

slint-1.6.0a8-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl (6.1 MB view hashes)

Uploaded CPython 3.10+ manylinux: glibc 2.17+ ARMv7l

slint-1.6.0a8-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (5.8 MB view hashes)

Uploaded CPython 3.10+ manylinux: glibc 2.17+ ARM64

slint-1.6.0a8-cp310-abi3-macosx_11_0_x86_64.whl (3.5 MB view hashes)

Uploaded CPython 3.10+ macOS 11.0+ x86-64

slint-1.6.0a8-cp310-abi3-macosx_11_0_arm64.whl (3.3 MB view hashes)

Uploaded CPython 3.10+ macOS 11.0+ ARM64

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page