slint

Slint-python (Beta)

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

Warning Slint-python is in a beta phase of development: The APIs while mostly stable, may be subject to further changes. Any changes will be documented in the ChangeLog.

You can track the progress for the Python integration by looking at python-labelled issues at https://github.com/slint-ui/slint/labels/a%3Alanguage-python .

Slint Language Manual

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

Prerequisites

Python 3
uv or pip

Installation

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

uv add slint

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

Quick Start

Create a new project with uv init.
Add the Slint Python package to your Python project: uv add slint
Create a file called app-window.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 => {
                root.request-increase-value();
            }
        }
    }
}

Create a file called main.py:

import slint

# slint.loader will look in `sys.path` for `app-window.slint`.
class App(slint.loader.app_window.AppWindow):
    @slint.callback
    def request_increase_value(self):
        self.counter = self.counter + 1

app = App()
app.run()

Run it with uv run main.py

API Overview

Instantiating a Component

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

app.slint

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:

Call slint.load_file("app.slint"). The returned object is a namespace, that provides the MainWindow class as well as any other explicitly exported component that inherits Window:
```
import slint
components = slint.load_file("app.slint")
main_window = components.MainWindow()
```
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 = slint.loader.app.MainWindow()
```
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.

If the file name contains a dash, like app-window.slint, an attribute lookup for app_window tries to locate app_window.slint and then fall back to app-window.slint.

Accessing Properties

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

main_window.counter = 42
print(main_window.counter)

Accessing Globals

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

For example, this Slint code declares a PrinterJobQueue singleton:

export global PrinterJobQueue {
    in-out property <int> job-count;
}

Access it as a property on the component instance by its name:

print("job count:", instance.PrinterJobQueue.job_count)

Note: Global singletons are instantiated once per component. When declaring multiple components for export to Python, each instance has their own associated globals singletons.

Setting and Invoking Callbacks

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

In Slint, callbacks are defined using the callback keyword and can be connected to another component's callback using the <=> syntax.

my-component.slint

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 functions.

main.py

import slint

component = slint.loader.my_component.MyComponent()
# connect to a callback

def clicked():
    print("hello")

component.clicked = clicked
// invoke a callback
component.clicked();

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

import slint

class Component(slint.loader.my_component.MyComponent):
    @slint.callback
    def clicked(self):
        print("hello")

component = Component()

The @slint.callback() decorator accepts a name argument, if 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

Each type used for properties in the Slint Language translates to a specific type in Python. The following table summarizes the 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`/`Struct`	When reading, structures are mapped to data classes, when writing dicts are also accepted.
array	`slint.Model`

Arrays and Models

You can set array properties 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]);
component.model.append(4)
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:"
        ..."""
        self.notify_row_changed(row)

When adding or inserting rows, call notify_row_added(row, count) on the super class. Similarly, when removing rows, notify Slint by calling notify_row_removed(row, count).

Structs

Structs declared in Slint and exposed to Python via export are then accessible in the namespace that is returned when instantiating a component.

app.slint

export struct MyData {
    name: string,
    age: int
}

export component MainWindow inherits Window {
    in-out property <MyData> data;
}

main.py

The exported MyData struct can be constructed as follows:

import slint
# Look for for `app.slint` in `sys.path`:
main_window = slint.loader.app.MainWindow()

data = slint.loader.app.MyData(name = "Simon")
data.age = 10
main_window.data = data

Third-Party Licenses

For a list of the third-party licenses of all dependencies, see the separate Third-Party Licenses page.

View Source

  1# Copyright © SixtyFPS GmbH <info@slint.dev>
  2# SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
  3
  4r"""
  5.. include:: ../README.md
  6"""
  7
  8import os
  9import sys
 10from . import slint as native
 11import types
 12import logging
 13import copy
 14import typing
 15from typing import Any
 16import pathlib
 17from .models import ListModel, Model
 18from .slint import Image, Color, Brush, Timer, TimerMode
 19from pathlib import Path
 20
 21Struct = native.PyStruct
 22
 23
 24class CompileError(Exception):
 25    message: str
 26    """The error message that produced this compile error."""
 27
 28    diagnostics: list[native.PyDiagnostic]
 29    """A list of detailed diagnostics that were produced as part of the compilation."""
 30
 31    def __init__(self, message: str, diagnostics: list[native.PyDiagnostic]):
 32        """@private"""
 33        self.message = message
 34        self.diagnostics = diagnostics
 35
 36
 37class Component:
 38    """Component is the base class for all instances of Slint components. Use the member functions to show or hide the
 39    window, or spin the event loop."""
 40
 41    __instance__: native.ComponentInstance
 42
 43    def show(self) -> None:
 44        """Shows the window on the screen."""
 45
 46        self.__instance__.show()
 47
 48    def hide(self) -> None:
 49        """Hides the window from the screen."""
 50
 51        self.__instance__.hide()
 52
 53    def run(self) -> None:
 54        """Shows the window, runs the event loop, hides it when the loop is quit, and returns."""
 55        self.__instance__.run()
 56
 57
 58def _normalize_prop(name: str) -> str:
 59    return name.replace("-", "_")
 60
 61
 62def _build_global_class(compdef: native.ComponentDefinition, global_name: str) -> Any:
 63    properties_and_callbacks = {}
 64
 65    for prop_name in compdef.global_properties(global_name).keys():
 66        python_prop = _normalize_prop(prop_name)
 67        if python_prop in properties_and_callbacks:
 68            logging.warning(f"Duplicated property {prop_name}")
 69            continue
 70
 71        def mk_setter_getter(prop_or_callback_name: str) -> property:
 72            def getter(self: Component) -> Any:
 73                return self.__instance__.get_global_property(
 74                    global_name, prop_or_callback_name
 75                )
 76
 77            def setter(self: Component, value: Any) -> None:
 78                self.__instance__.set_global_property(
 79                    global_name, prop_or_callback_name, value
 80                )
 81
 82            return property(getter, setter)
 83
 84        properties_and_callbacks[python_prop] = mk_setter_getter(prop_name)
 85
 86    for callback_name in compdef.global_callbacks(global_name):
 87        python_prop = _normalize_prop(callback_name)
 88        if python_prop in properties_and_callbacks:
 89            logging.warning(f"Duplicated property {prop_name}")
 90            continue
 91
 92        def mk_setter_getter(prop_or_callback_name: str) -> property:
 93            def getter(self: Component) -> typing.Callable[..., Any]:
 94                def call(*args: Any) -> Any:
 95                    return self.__instance__.invoke_global(
 96                        global_name, prop_or_callback_name, *args
 97                    )
 98
 99                return call
100
101            def setter(self: Component, value: typing.Callable[..., Any]) -> None:
102                self.__instance__.set_global_callback(
103                    global_name, prop_or_callback_name, value
104                )
105
106            return property(getter, setter)
107
108        properties_and_callbacks[python_prop] = mk_setter_getter(callback_name)
109
110    for function_name in compdef.global_functions(global_name):
111        python_prop = _normalize_prop(function_name)
112        if python_prop in properties_and_callbacks:
113            logging.warning(f"Duplicated function {prop_name}")
114            continue
115
116        def mk_getter(function_name: str) -> property:
117            def getter(self: Component) -> typing.Callable[..., Any]:
118                def call(*args: Any) -> Any:
119                    return self.__instance__.invoke_global(
120                        global_name, function_name, *args
121                    )
122
123                return call
124
125            return property(getter)
126
127        properties_and_callbacks[python_prop] = mk_getter(function_name)
128
129    return type("SlintGlobalClassWrapper", (), properties_and_callbacks)
130
131
132def _build_class(
133    compdef: native.ComponentDefinition,
134) -> typing.Callable[..., Component]:
135    def cls_init(self: Component, **kwargs: Any) -> Any:
136        self.__instance__ = compdef.create()
137        for name, value in self.__class__.__dict__.items():
138            if hasattr(value, "slint.callback"):
139                callback_info = getattr(value, "slint.callback")
140                name = callback_info["name"]
141
142                def mk_callback(
143                    self: Any, callback: typing.Callable[..., Any]
144                ) -> typing.Callable[..., Any]:
145                    def invoke(*args: Any, **kwargs: Any) -> Any:
146                        return callback(self, *args, **kwargs)
147
148                    return invoke
149
150                if "global_name" in callback_info:
151                    self.__instance__.set_global_callback(
152                        callback_info["global_name"], name, mk_callback(self, value)
153                    )
154                else:
155                    self.__instance__.set_callback(name, mk_callback(self, value))
156
157        for prop, val in kwargs.items():
158            setattr(self, prop, val)
159
160    properties_and_callbacks: dict[Any, Any] = {"__init__": cls_init}
161
162    for prop_name in compdef.properties.keys():
163        python_prop = _normalize_prop(prop_name)
164        if python_prop in properties_and_callbacks:
165            logging.warning(f"Duplicated property {prop_name}")
166            continue
167
168        def mk_setter_getter(prop_or_callback_name: str) -> property:
169            def getter(self: Component) -> Any:
170                return self.__instance__.get_property(prop_or_callback_name)
171
172            def setter(self: Component, value: Any) -> None:
173                self.__instance__.set_property(prop_or_callback_name, value)
174
175            return property(getter, setter)
176
177        properties_and_callbacks[python_prop] = mk_setter_getter(prop_name)
178
179    for callback_name in compdef.callbacks:
180        python_prop = _normalize_prop(callback_name)
181        if python_prop in properties_and_callbacks:
182            logging.warning(f"Duplicated property {prop_name}")
183            continue
184
185        def mk_setter_getter(prop_or_callback_name: str) -> property:
186            def getter(self: Component) -> typing.Callable[..., Any]:
187                def call(*args: Any) -> Any:
188                    return self.__instance__.invoke(prop_or_callback_name, *args)
189
190                return call
191
192            def setter(self: Component, value: typing.Callable[..., Any]) -> None:
193                self.__instance__.set_callback(prop_or_callback_name, value)
194
195            return property(getter, setter)
196
197        properties_and_callbacks[python_prop] = mk_setter_getter(callback_name)
198
199    for function_name in compdef.functions:
200        python_prop = _normalize_prop(function_name)
201        if python_prop in properties_and_callbacks:
202            logging.warning(f"Duplicated function {prop_name}")
203            continue
204
205        def mk_getter(function_name: str) -> property:
206            def getter(self: Component) -> typing.Callable[..., Any]:
207                def call(*args: Any) -> Any:
208                    return self.__instance__.invoke(function_name, *args)
209
210                return call
211
212            return property(getter)
213
214        properties_and_callbacks[python_prop] = mk_getter(function_name)
215
216    for global_name in compdef.globals:
217        global_class = _build_global_class(compdef, global_name)
218
219        def mk_global(global_class: typing.Callable[..., Any]) -> property:
220            def global_getter(self: Component) -> Any:
221                wrapper = global_class()
222                setattr(wrapper, "__instance__", self.__instance__)
223                return wrapper
224
225            return property(global_getter)
226
227        properties_and_callbacks[global_name] = mk_global(global_class)
228
229    return type("SlintClassWrapper", (Component,), properties_and_callbacks)
230
231
232def _build_struct(name: str, struct_prototype: native.PyStruct) -> type:
233    def new_struct(cls: Any, *args: Any, **kwargs: Any) -> native.PyStruct:
234        inst = copy.copy(struct_prototype)
235
236        for prop, val in kwargs.items():
237            setattr(inst, prop, val)
238
239        return inst
240
241    type_dict = {
242        "__new__": new_struct,
243    }
244
245    return type(name, (), type_dict)
246
247
248def load_file(
249    path: str | os.PathLike[Any] | pathlib.Path,
250    quiet: bool = False,
251    style: typing.Optional[str] = None,
252    include_paths: typing.Optional[typing.List[os.PathLike[Any] | pathlib.Path]] = None,
253    library_paths: typing.Optional[
254        typing.Dict[str, os.PathLike[Any] | pathlib.Path]
255    ] = None,
256    translation_domain: typing.Optional[str] = None,
257) -> types.SimpleNamespace:
258    """This function is the low-level entry point into Slint for instantiating components. It loads the `.slint` file at
259    the specified `path` and returns a namespace with all exported components as Python classes, as well as enums, and structs.
260
261    * `quiet`: Set to true to prevent any warnings during compilation from being printed to stderr.
262    * `style`: Specify a widget style.
263    * `include_paths`: Additional include paths used to look up `.slint` files imported from other `.slint` files.
264    * `library_paths`: A dictionary that maps library names to their location in the file system. This is then used to look up
265       library imports, such as `import { MyButton } from "@mylibrary";`.
266    * `translation_domain`: The domain to use for looking up the catalogue run-time translations. This must match the
267       translation domain used when extracting translations with `slint-tr-extractor`.
268
269    """
270
271    compiler = native.Compiler()
272
273    if style is not None:
274        compiler.style = style
275    if include_paths is not None:
276        compiler.include_paths = include_paths
277    if library_paths is not None:
278        compiler.library_paths = library_paths
279    if translation_domain is not None:
280        compiler.translation_domain = translation_domain
281
282    result = compiler.build_from_path(Path(path))
283
284    diagnostics = result.diagnostics
285    if diagnostics:
286        if not quiet:
287            for diag in diagnostics:
288                if diag.level == native.DiagnosticLevel.Warning:
289                    logging.warning(diag)
290
291        errors = [
292            diag for diag in diagnostics if diag.level == native.DiagnosticLevel.Error
293        ]
294        if errors:
295            raise CompileError(f"Could not compile {path}", diagnostics)
296
297    module = types.SimpleNamespace()
298    for comp_name in result.component_names:
299        wrapper_class = _build_class(result.component(comp_name))
300
301        setattr(module, comp_name, wrapper_class)
302
303    for name, struct_or_enum_prototype in result.structs_and_enums.items():
304        name = _normalize_prop(name)
305        struct_wrapper = _build_struct(name, struct_or_enum_prototype)
306        setattr(module, name, struct_wrapper)
307
308    for orig_name, new_name in result.named_exports:
309        orig_name = _normalize_prop(orig_name)
310        new_name = _normalize_prop(new_name)
311        setattr(module, new_name, getattr(module, orig_name))
312
313    return module
314
315
316class SlintAutoLoader:
317    def __init__(self, base_dir: Path | None = None):
318        self.local_dirs: typing.List[Path] | None = None
319        if base_dir:
320            self.local_dirs = [base_dir]
321
322    def __getattr__(self, name: str) -> Any:
323        for path in self.local_dirs or sys.path:
324            dir_candidate = Path(path) / name
325            if os.path.isdir(dir_candidate):
326                loader = SlintAutoLoader(dir_candidate)
327                setattr(self, name, loader)
328                return loader
329
330            file_candidate = dir_candidate.with_suffix(".slint")
331            if os.path.isfile(file_candidate):
332                type_namespace = load_file(file_candidate)
333                setattr(self, name, type_namespace)
334                return type_namespace
335
336            dir_candidate = Path(path) / name.replace("_", "-")
337            file_candidate = dir_candidate.with_suffix(".slint")
338            if os.path.isfile(file_candidate):
339                type_namespace = load_file(file_candidate)
340                setattr(self, name, type_namespace)
341                return type_namespace
342
343        return None
344
345
346loader = SlintAutoLoader()
347"""Use the global `loader` object to load Slint files from the file system. It exposes two stages of attributes:
3481. Any lookup of an attribute in the loader tries to match a file in `sys.path` with the `.slint` extension. For example
349   `loader.my_component` looks for a file `my_component.slint` in the directories in `sys.path`.
3502. Any lookup in the object returned by the first stage tries to match an exported component in the loaded file, or a
351   struct, or enum. For example `loader.my_component.MyComponent` looks for an *exported* component named `MyComponent`
352   in the file `my_component.slint`.
353
354**Note:** The first entry in the module search path `sys.path` is the directory that contains the input script.
355
356Example:
357```python
358import slint
359# Look for a file `main.slint` in the current directory,
360# #load & compile it, and instantiate the exported `MainWindow` component
361main_window = slint.loader.main_window.MainWindow()
362main_window.show()
363...
364```
365"""
366
367
368def _callback_decorator(
369    callable: typing.Callable[..., Any], info: typing.Dict[str, Any]
370) -> typing.Callable[..., Any]:
371    if "name" not in info:
372        info["name"] = callable.__name__
373    setattr(callable, "slint.callback", info)
374    return callable
375
376
377def callback(
378    global_name: str | None = None, name: str | None = None
379) -> typing.Callable[..., Any]:
380    """Use the callback decorator to mark a method as a callback that can be invoked from the Slint component.
381
382    For the decorator to work, the method must be a member of a class that is Slint component.
383
384    Example:
385    ```python
386    import slint
387
388    class AppMainWindow(slint.loader.main_window.MainWindow):
389
390        # Automatically connected to a callback button_clicked()
391        # in main_window.slint's MainWindow.
392        @slint.callback()
393        def button_clicked(self):
394            print("Button clicked")
395
396    ...
397    ```
398
399    If your Python method has a different name from the Slint component's callback, use the `name` parameter to specify
400    the correct name. Similarly, use the `global_name` parameter to specify the name of the correct global singleton in
401    the Slint component.
402    """
403
404    if callable(global_name):
405        callback = global_name
406        return _callback_decorator(callback, {})
407    else:
408        info = {}
409        if name:
410            info["name"] = name
411        if global_name:
412            info["global_name"] = global_name
413        return lambda callback: _callback_decorator(callback, info)
414
415
416def set_xdg_app_id(app_id: str) -> None:
417    """Sets the application id for use on Wayland or X11 with [xdg](https://specifications.freedesktop.org/desktop-entry-spec/latest/)
418    compliant window managers. This id must be set before the window is shown; it only applies to Wayland or X11."""
419
420    native.set_xdg_app_id(app_id)
421
422
423__all__ = [
424    "CompileError",
425    "Component",
426    "load_file",
427    "loader",
428    "Image",
429    "Color",
430    "Brush",
431    "Model",
432    "ListModel",
433    "Timer",
434    "TimerMode",
435    "set_xdg_app_id",
436    "callback",
437]

class CompileError(builtins.Exception): View Source

25class CompileError(Exception):
26    message: str
27    """The error message that produced this compile error."""
28
29    diagnostics: list[native.PyDiagnostic]
30    """A list of detailed diagnostics that were produced as part of the compilation."""
31
32    def __init__(self, message: str, diagnostics: list[native.PyDiagnostic]):
33        """@private"""
34        self.message = message
35        self.diagnostics = diagnostics

Common base class for all non-exit exceptions.

message: str

The error message that produced this compile error.

diagnostics: list[PyDiagnostic]

A list of detailed diagnostics that were produced as part of the compilation.

class Component: View Source

38class Component:
39    """Component is the base class for all instances of Slint components. Use the member functions to show or hide the
40    window, or spin the event loop."""
41
42    __instance__: native.ComponentInstance
43
44    def show(self) -> None:
45        """Shows the window on the screen."""
46
47        self.__instance__.show()
48
49    def hide(self) -> None:
50        """Hides the window from the screen."""
51
52        self.__instance__.hide()
53
54    def run(self) -> None:
55        """Shows the window, runs the event loop, hides it when the loop is quit, and returns."""
56        self.__instance__.run()

Component is the base class for all instances of Slint components. Use the member functions to show or hide the window, or spin the event loop.

def show(self) -> None: View Source

44    def show(self) -> None:
45        """Shows the window on the screen."""
46
47        self.__instance__.show()

Shows the window on the screen.

def hide(self) -> None: View Source

49    def hide(self) -> None:
50        """Hides the window from the screen."""
51
52        self.__instance__.hide()

Hides the window from the screen.

def run(self) -> None: View Source

54    def run(self) -> None:
55        """Shows the window, runs the event loop, hides it when the loop is quit, and returns."""
56        self.__instance__.run()

Shows the window, runs the event loop, hides it when the loop is quit, and returns.

def load_file( path: str | os.PathLike[typing.Any] | pathlib.Path, quiet: bool = False, style: Optional[str] = None, include_paths: Optional[List[os.PathLike[Any] | pathlib.Path]] = None, library_paths: Optional[Dict[str, os.PathLike[Any] | pathlib.Path]] = None, translation_domain: Optional[str] = None) -> types.SimpleNamespace: View Source

249def load_file(
250    path: str | os.PathLike[Any] | pathlib.Path,
251    quiet: bool = False,
252    style: typing.Optional[str] = None,
253    include_paths: typing.Optional[typing.List[os.PathLike[Any] | pathlib.Path]] = None,
254    library_paths: typing.Optional[
255        typing.Dict[str, os.PathLike[Any] | pathlib.Path]
256    ] = None,
257    translation_domain: typing.Optional[str] = None,
258) -> types.SimpleNamespace:
259    """This function is the low-level entry point into Slint for instantiating components. It loads the `.slint` file at
260    the specified `path` and returns a namespace with all exported components as Python classes, as well as enums, and structs.
261
262    * `quiet`: Set to true to prevent any warnings during compilation from being printed to stderr.
263    * `style`: Specify a widget style.
264    * `include_paths`: Additional include paths used to look up `.slint` files imported from other `.slint` files.
265    * `library_paths`: A dictionary that maps library names to their location in the file system. This is then used to look up
266       library imports, such as `import { MyButton } from "@mylibrary";`.
267    * `translation_domain`: The domain to use for looking up the catalogue run-time translations. This must match the
268       translation domain used when extracting translations with `slint-tr-extractor`.
269
270    """
271
272    compiler = native.Compiler()
273
274    if style is not None:
275        compiler.style = style
276    if include_paths is not None:
277        compiler.include_paths = include_paths
278    if library_paths is not None:
279        compiler.library_paths = library_paths
280    if translation_domain is not None:
281        compiler.translation_domain = translation_domain
282
283    result = compiler.build_from_path(Path(path))
284
285    diagnostics = result.diagnostics
286    if diagnostics:
287        if not quiet:
288            for diag in diagnostics:
289                if diag.level == native.DiagnosticLevel.Warning:
290                    logging.warning(diag)
291
292        errors = [
293            diag for diag in diagnostics if diag.level == native.DiagnosticLevel.Error
294        ]
295        if errors:
296            raise CompileError(f"Could not compile {path}", diagnostics)
297
298    module = types.SimpleNamespace()
299    for comp_name in result.component_names:
300        wrapper_class = _build_class(result.component(comp_name))
301
302        setattr(module, comp_name, wrapper_class)
303
304    for name, struct_or_enum_prototype in result.structs_and_enums.items():
305        name = _normalize_prop(name)
306        struct_wrapper = _build_struct(name, struct_or_enum_prototype)
307        setattr(module, name, struct_wrapper)
308
309    for orig_name, new_name in result.named_exports:
310        orig_name = _normalize_prop(orig_name)
311        new_name = _normalize_prop(new_name)
312        setattr(module, new_name, getattr(module, orig_name))
313
314    return module

This function is the low-level entry point into Slint for instantiating components. It loads the .slint file at the specified path and returns a namespace with all exported components as Python classes, as well as enums, and structs.

quiet: Set to true to prevent any warnings during compilation from being printed to stderr.
style: Specify a widget style.
include_paths: Additional include paths used to look up .slint files imported from other .slint files.
library_paths: A dictionary that maps library names to their location in the file system. This is then used to look up library imports, such as import { MyButton } from "@mylibrary";.
translation_domain: The domain to use for looking up the catalogue run-time translations. This must match the translation domain used when extracting translations with slint-tr-extractor.

loader = <slint.SlintAutoLoader object>

Use the global loader object to load Slint files from the file system. It exposes two stages of attributes:

Any lookup of an attribute in the loader tries to match a file in sys.path with the .slint extension. For example loader.my_component looks for a file my_component.slint in the directories in sys.path.
Any lookup in the object returned by the first stage tries to match an exported component in the loaded file, or a struct, or enum. For example loader.my_component.MyComponent looks for an exported component named MyComponent in the file my_component.slint.

Note: The first entry in the module search path sys.path is the directory that contains the input script.

Example:

import slint
# Look for a file `main.slint` in the current directory,
# #load & compile it, and instantiate the exported `MainWindow` component
main_window = slint.loader.main_window.MainWindow()
main_window.show()
...

class Image:

Image objects can be set on Slint Image elements for display. Use Image.load_from_path to construct Image objects from a path to an image file on disk.

def load_from_path(path):

Loads the image from the specified path. Returns None if the image can't be loaded.

def load_from_svg_data(data):

Creates a new image from a string that describes the image in SVG format.

path

The path of the image if it was loaded from disk, or None.

height

The height of the image in pixels.

width

The width of the image in pixels.

size

The size of the image as tuple of width and height.

class Color:

A Color object represents a color in the RGB color space with an alpha. Each color channel and the alpha is represented as an 8-bit integer. The alpha channel is 0 for fully transparent and 255 for fully opaque.

Construct colors from a CSS color string, or by specifying the red, green, blue, and (optional) alpha channels in a dict.

def brighter(self, /, factor):

Returns a new color that is brighter than this color by the given factor.

def darker(self, /, factor):

Returns a new color that is darker than this color by the given factor.

def transparentize(self, /, factor):

Returns a new version of this color with the opacity decreased by factor.

The transparency is obtained by multiplying the alpha channel by (1 - factor).

def mix(self, /, other, factor):

Returns a new color that is a mix of this color and other. The specified factor is clamped to be between 0.0 and 1.0 and then applied to this color, while 1.0 - factor is applied to other.

def with_alpha(self, /, alpha):

Returns a new version of this color with the opacity set to alpha.

red

The red channel.

alpha

The alpha channel.

green

The green channel.

blue

The blue channel.

class Brush:

A brush is a data structure that is used to describe how a shape, such as a rectangle, path or even text, shall be filled. A brush can also be applied to the outline of a shape, that means the fill of the outline itself.

Brushes can only be constructed from solid colors.

Note: In future, we plan to reduce this constraint and allow for declaring graidient brushes programmatically.

def is_transparent(self, /):

Returns true if this brush contains a fully transparent color (alpha value is zero).

def is_opaque(self, /):

Returns true if this brush is fully opaque.

def brighter(self, /, factor):

Returns a new version of this brush that has the brightness increased by the specified factor. This is done by calling Color.brighter on all the colors of this brush.

def darker(self, /, factor):

Returns a new version of this brush that has the brightness decreased by the specified factor. This is done by calling Color.darker on all the color of this brush.

def transparentize(self, /, amount):

Returns a new version of this brush with the opacity decreased by factor.

The transparency is obtained by multiplying the alpha channel by (1 - factor).

See also Color.transparentize.

def with_alpha(self, /, alpha):

Returns a new version of this brush with the related color's opacities set to alpha.

color

The brush's color.

class Model(builtins.PyModelBase, collections.abc.Iterable[T], typing.Generic[T]): View Source

12class Model[T](native.PyModelBase, Iterable[T]):
13    """Model is the base class for feeding dynamic data into Slint views.
14
15    Subclass Model to implement your own models, or use `ListModel` to wrap a list.
16
17    Models are iterable and can be used in for loops."""
18
19    def __new__(cls, *args: Any) -> "Model[T]":
20        return super().__new__(cls)
21
22    def __init__(self) -> None:
23        self.init_self(self)
24
25    def __len__(self) -> int:
26        return self.row_count()
27
28    def __getitem__(self, index: int) -> typing.Optional[T]:
29        return self.row_data(index)
30
31    def __setitem__(self, index: int, value: T) -> None:
32        self.set_row_data(index, value)
33
34    def __iter__(self) -> Iterator[T]:
35        return ModelIterator(self)
36
37    def set_row_data(self, row: int, value: T) -> None:
38        """Call this method on mutable models to change the data for the given row.
39        The UI will also call this method when modifying a model's data.
40        Re-implement this method in a sub-class to handle the change."""
41        super().set_row_data(row, value)
42
43    @abstractmethod
44    def row_data(self, row: int) -> typing.Optional[T]:
45        """Returns the data for the given row.
46        Re-implement this method in a sub-class to provide the data."""
47        return cast(T, super().row_data(row))
48
49    def notify_row_changed(self, row: int) -> None:
50        """Call this method from a sub-class to notify the views that a row has changed."""
51        super().notify_row_changed(row)
52
53    def notify_row_removed(self, row: int, count: int) -> None:
54        """Call this method from a sub-class to notify the views that
55        `count` rows have been removed starting at `row`."""
56        super().notify_row_removed(row, count)
57
58    def notify_row_added(self, row: int, count: int) -> None:
59        """Call this method from a sub-class to notify the views that
60        `count` rows have been added starting at `row`."""
61        super().notify_row_added(row, count)

Model is the base class for feeding dynamic data into Slint views.

Subclass Model to implement your own models, or use ListModel to wrap a list.

Models are iterable and can be used in for loops.

def set_row_data(self, row: int, value: T) -> None: View Source

37    def set_row_data(self, row: int, value: T) -> None:
38        """Call this method on mutable models to change the data for the given row.
39        The UI will also call this method when modifying a model's data.
40        Re-implement this method in a sub-class to handle the change."""
41        super().set_row_data(row, value)

Call this method on mutable models to change the data for the given row. The UI will also call this method when modifying a model's data. Re-implement this method in a sub-class to handle the change.

@abstractmethod

def row_data(self, row: int) -> Optional[T]: View Source

43    @abstractmethod
44    def row_data(self, row: int) -> typing.Optional[T]:
45        """Returns the data for the given row.
46        Re-implement this method in a sub-class to provide the data."""
47        return cast(T, super().row_data(row))

Returns the data for the given row. Re-implement this method in a sub-class to provide the data.

def notify_row_changed(self, /, index):

Call this method from a sub-class to notify the views that a row has changed.

def notify_row_removed(self, /, index, count):

Call this method from a sub-class to notify the views that count rows have been removed starting at row.

def notify_row_added(self, /, index, count):

Call this method from a sub-class to notify the views that count rows have been added starting at row.

class ListModel(slint.Model[T], typing.Generic[T]): View Source

 64class ListModel[T](Model[T]):
 65    """ListModel is a `Model` that stores its data in a Python list.
 66
 67    Construct a ListMode from an iterable (such as a list itself).
 68    Use `ListModel.append()` to add items to the model, and use the
 69    `del` statement to remove items.
 70
 71    Any changes to the model are automatically reflected in the views
 72    in UI they're used with.
 73    """
 74
 75    def __init__(self, iterable: typing.Optional[Iterable[T]] = None):
 76        """Constructs a new ListModel from the give iterable. All the values
 77        the iterable produces are stored in a list."""
 78
 79        super().__init__()
 80        if iterable is not None:
 81            self.list = list(iterable)
 82        else:
 83            self.list = []
 84
 85    def row_count(self) -> int:
 86        return len(self.list)
 87
 88    def row_data(self, row: int) -> typing.Optional[T]:
 89        return self.list[row]
 90
 91    def set_row_data(self, row: int, data: T) -> None:
 92        self.list[row] = data
 93        super().notify_row_changed(row)
 94
 95    def __delitem__(self, key: int | slice) -> None:
 96        if isinstance(key, slice):
 97            start, stop, step = key.indices(len(self.list))
 98            del self.list[key]
 99            count = len(range(start, stop, step))
100            super().notify_row_removed(start, count)
101        else:
102            del self.list[key]
103            super().notify_row_removed(key, 1)
104
105    def append(self, value: T) -> None:
106        """Appends the value to the end of the list."""
107        index = len(self.list)
108        self.list.append(value)
109        super().notify_row_added(index, 1)

ListModel is a Model that stores its data in a Python list.

Construct a ListMode from an iterable (such as a list itself). Use ListModel.append() to add items to the model, and use the del statement to remove items.

Any changes to the model are automatically reflected in the views in UI they're used with.

ListModel(iterable: Optional[Iterable[T]] = None) View Source

75    def __init__(self, iterable: typing.Optional[Iterable[T]] = None):
76        """Constructs a new ListModel from the give iterable. All the values
77        the iterable produces are stored in a list."""
78
79        super().__init__()
80        if iterable is not None:
81            self.list = list(iterable)
82        else:
83            self.list = []

Constructs a new ListModel from the give iterable. All the values the iterable produces are stored in a list.

def row_count(self) -> int: View Source

85    def row_count(self) -> int:
86        return len(self.list)

def row_data(self, row: int) -> Optional[T]: View Source

88    def row_data(self, row: int) -> typing.Optional[T]:
89        return self.list[row]

Returns the data for the given row. Re-implement this method in a sub-class to provide the data.

def set_row_data(self, row: int, data: T) -> None: View Source

91    def set_row_data(self, row: int, data: T) -> None:
92        self.list[row] = data
93        super().notify_row_changed(row)

Call this method on mutable models to change the data for the given row. The UI will also call this method when modifying a model's data. Re-implement this method in a sub-class to handle the change.

def append(self, value: T) -> None: View Source

105    def append(self, value: T) -> None:
106        """Appends the value to the end of the list."""
107        index = len(self.list)
108        self.list.append(value)
109        super().notify_row_added(index, 1)

Appends the value to the end of the list.

class Timer:

Timer is a handle to the timer system that triggers a callback after a specified period of time.

Use Timer.start() to create a timer that that repeatedly triggers a callback, or Timer.single_shot() to trigger a callback only once.

The timer will automatically stop when garbage collected. You must keep the Timer object around for as long as you want the timer to keep firing.

Timers can only be used in the thread that runs the Slint event loop. They don't fire if used in another thread.

def start(self, /, mode, interval, callback):

Starts the timer with the given mode and interval, in order for the callback to called when the timer fires. If the timer has been started previously and not fired yet, then it will be restarted.

Arguments:

mode: The timer mode to apply, i.e. whether to repeatedly fire the timer or just once.
interval: The duration from now until when the timer should firethe first time, and subsequently for TimerMode.Repeated timers.
callback: The function to call when the time has been reached or exceeded.

def single_shot(duration, callback):

Starts the timer with the duration and the callback to called when the timer fires. It is fired only once and then deleted.

Arguments:

duration: The duration from now until when the timer should fire.
callback: The function to call when the time has been reached or exceeded.

def stop(self, /):

Stops the previously started timer. Does nothing if the timer has never been started.

def restart(self, /):

Restarts the timer. If the timer was previously started by calling Timer.start() with a duration and callback, then the time when the callback will be next invoked is re-calculated to be in the specified duration relative to when this function is called.

Does nothing if the timer was never started.

running

Set to true if the timer is running; false otherwise.

interval

The duration of timer.

When setting this property and the timer is running (see Timer.running), then the time when the callback will be next invoked is re-calculated to be in the specified duration relative to when this property is set.

class TimerMode:

The TimerMode specifies what should happen after the timer fired.

Used by the Timer.start() function.

SingleShot = TimerMode.SingleShot

Repeated = TimerMode.Repeated

def set_xdg_app_id(app_id: str) -> None: View Source

417def set_xdg_app_id(app_id: str) -> None:
418    """Sets the application id for use on Wayland or X11 with [xdg](https://specifications.freedesktop.org/desktop-entry-spec/latest/)
419    compliant window managers. This id must be set before the window is shown; it only applies to Wayland or X11."""
420
421    native.set_xdg_app_id(app_id)

Sets the application id for use on Wayland or X11 with xdg compliant window managers. This id must be set before the window is shown; it only applies to Wayland or X11.

def callback( global_name: str | None = None, name: str | None = None) -> Callable[..., Any]: View Source

378def callback(
379    global_name: str | None = None, name: str | None = None
380) -> typing.Callable[..., Any]:
381    """Use the callback decorator to mark a method as a callback that can be invoked from the Slint component.
382
383    For the decorator to work, the method must be a member of a class that is Slint component.
384
385    Example:
386    ```python
387    import slint
388
389    class AppMainWindow(slint.loader.main_window.MainWindow):
390
391        # Automatically connected to a callback button_clicked()
392        # in main_window.slint's MainWindow.
393        @slint.callback()
394        def button_clicked(self):
395            print("Button clicked")
396
397    ...
398    ```
399
400    If your Python method has a different name from the Slint component's callback, use the `name` parameter to specify
401    the correct name. Similarly, use the `global_name` parameter to specify the name of the correct global singleton in
402    the Slint component.
403    """
404
405    if callable(global_name):
406        callback = global_name
407        return _callback_decorator(callback, {})
408    else:
409        info = {}
410        if name:
411            info["name"] = name
412        if global_name:
413            info["global_name"] = global_name
414        return lambda callback: _callback_decorator(callback, info)

Use the callback decorator to mark a method as a callback that can be invoked from the Slint component.

For the decorator to work, the method must be a member of a class that is Slint component.

Example:

import slint

class AppMainWindow(slint.loader.main_window.MainWindow):

    # Automatically connected to a callback button_clicked()
    # in main_window.slint's MainWindow.
    @slint.callback()
    def button_clicked(self):
        print("Button clicked")

...

If your Python method has a different name from the Slint component's callback, use the name parameter to specify the correct name. Similarly, use the global_name parameter to specify the name of the correct global singleton in the Slint component.