python: add .slint code generator and typing metadata

 - introduce slint.codegen to emit runtime modules and stubs from .slint inputs via CLI or API
 - expose property/callback metadata in the bindings, extend callback decorator overloads, and add libcst-backed emitters for typed modules
 - document the workflow, add a counter example plus tests, and keep the legacy import-loader path for now

Author: GreyElaina

api/python/slint/Cargo.toml

@@ -53,6 +53,7 @@ spin_on = { workspace = true }
 css-color-parser2 = { workspace = true }
 pyo3-stub-gen = { version = "0.9.0", default-features = false }
 smol = { version = "2.0.0" }
+smol_str = { workspace = true }
 
 [package.metadata.maturin]
 python-source = "slint"

api/python/slint/README.md

@@ -75,6 +75,33 @@ app.run()
 
 5. Run it with `uv run main.py`
 
+## Code Generation CLI
+
+Use the bundled code generator to derive Python bindings and type stubs from your `.slint` files. The generator lives in the `slint.codegen` module and exposes a CLI entry point.
+
+Run it with `uv`:
+
+```bash
+uv run -m slint.codegen generate --input path/to/app.slint --output generated
+```
+
+When `--output` is omitted the generated files are written next to each input source.
+
+You can also call the generator from Python:
+
+```python
+from pathlib import Path
+from slint.codegen.generator import generate_project
+from slint.codegen.models import GenerationConfig
+
+slint_file = Path("ui/app.slint")
+generate_project(
+    inputs=[slint_file],
+    output_dir=Path("generated"),
+    config=GenerationConfig(include_paths=[slint_file.parent], library_paths={}, style=None, translation_domain=None, quiet=True),
+)
+```
+
 ## API Overview
 
 ### Instantiating a Component

api/python/slint/interpreter.rs

@@ -18,6 +18,7 @@ use pyo3::gc::PyVisit;
 use pyo3::prelude::*;
 use pyo3::types::PyTuple;
 use pyo3::PyTraverseError;
+use smol_str::SmolStr;
 
 use crate::errors::{
     PyGetPropertyError, PyInvokeError, PyPlatformError, PySetCallbackError, PySetPropertyError,
@@ -255,6 +256,39 @@ impl ComponentDefinition {
         self.definition.globals().collect()
     }
 
+    fn property_infos(&self) -> Vec<PyPropertyInfo> {
+        self.definition
+            .properties_and_callbacks()
+            .filter_map(|(name, (ty, _))| {
+                if ty.is_property_type() {
+                    Some(PyPropertyInfo::new(name, &ty))
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
+    fn callback_infos(&self) -> Vec<PyCallbackInfo> {
+        self.definition
+            .properties_and_callbacks()
+            .filter_map(|(name, (ty, _))| match ty {
+                Type::Callback(function) => Some(PyCallbackInfo::new(name, &function)),
+                _ => None,
+            })
+            .collect()
+    }
+
+    fn function_infos(&self) -> Vec<PyFunctionInfo> {
+        self.definition
+            .properties_and_callbacks()
+            .filter_map(|(name, (ty, _))| match ty {
+                Type::Function(function) => Some(PyFunctionInfo::new(name, &function)),
+                _ => None,
+            })
+            .collect()
+    }
+
     fn global_properties(&self, name: &str) -> Option<IndexMap<String, PyValueType>> {
         self.definition.global_properties_and_callbacks(name).map(|propiter| {
             propiter
@@ -271,6 +305,39 @@ impl ComponentDefinition {
         self.definition.global_functions(name).map(|functioniter| functioniter.collect())
     }
 
+    fn global_property_infos(&self, global_name: &str) -> Option<Vec<PyPropertyInfo>> {
+        self.definition.global_properties_and_callbacks(global_name).map(|iter| {
+            iter.filter_map(|(name, (ty, _))| {
+                if ty.is_property_type() {
+                    Some(PyPropertyInfo::new(name, &ty))
+                } else {
+                    None
+                }
+            })
+            .collect()
+        })
+    }
+
+    fn global_callback_infos(&self, global_name: &str) -> Option<Vec<PyCallbackInfo>> {
+        self.definition.global_properties_and_callbacks(global_name).map(|iter| {
+            iter.filter_map(|(name, (ty, _))| match ty {
+                Type::Callback(function) => Some(PyCallbackInfo::new(name, &function)),
+                _ => None,
+            })
+            .collect()
+        })
+    }
+
+    fn global_function_infos(&self, global_name: &str) -> Option<Vec<PyFunctionInfo>> {
+        self.definition.global_properties_and_callbacks(global_name).map(|iter| {
+            iter.filter_map(|(name, (ty, _))| match ty {
+                Type::Function(function) => Some(PyFunctionInfo::new(name, &function)),
+                _ => None,
+            })
+            .collect()
+        })
+    }
+
     fn callback_returns_void(&self, callback_name: &str) -> bool {
         let callback_name = normalize_identifier(callback_name);
         self.definition
@@ -357,6 +424,183 @@ impl From<i_slint_compiler::langtype::Type> for PyValueType {
     }
 }
 
+fn python_identifier(name: &str) -> String {
+    if name.is_empty() {
+        return String::new();
+    }
+    let mut result = name.replace('-', "_");
+    if result.chars().next().is_some_and(|c| c.is_ascii_digit()) {
+        result.insert(0, '_');
+    }
+    result
+}
+
+fn type_to_python_hint(ty: &i_slint_compiler::langtype::Type) -> String {
+    use i_slint_compiler::langtype::Type::*;
+
+    match ty {
+        Void => "None".into(),
+        Bool => "bool".into(),
+        Int32 => "int".into(),
+        Float32 | Duration | PhysicalLength | LogicalLength | Rem | Angle | Percent
+        | UnitProduct(_) => "float".into(),
+        String => "str".into(),
+        Brush | Color => "slint.Brush".into(),
+        Image => "slint.Image".into(),
+        Model => "slint.Model".into(),
+        Array(inner) => format!("slint.ListModel[{}]", type_to_python_hint(inner)),
+        Struct(struct_ty) => struct_to_python_hint(struct_ty),
+        // Enumeration(enum_ty) => {
+        //     let name = enum_ty.name.as_str();
+        //     let tail = name.rsplit("::").next().unwrap_or(name);
+        //     format!("slint.{}", python_identifier(tail))
+        // }
+        Callback(function) | Function(function) => function_to_python_hint(function),
+        // ComponentFactory => "slint.ComponentFactory".into(),  // TODO
+        // PathData | Easing | ElementReference | LayoutCache | InferredProperty
+        // | InferredCallback | Invalid => "Any".into(),
+        _ => "Any".into(),
+    }
+}
+
+fn struct_to_python_hint(struct_ty: &Rc<i_slint_compiler::langtype::Struct>) -> String {
+    if let Some(inner_ty) = optional_struct_inner(struct_ty) {
+        return format!("Optional[{}]", type_to_python_hint(inner_ty));
+    }
+
+    if let Some(name) = &struct_ty.name {
+        let full = name.as_str();
+        let tail = full.rsplit("::").next().unwrap_or(full);
+        if full.starts_with("slint::") {
+            return format!("slint.{}", python_identifier(tail));
+        }
+        return python_identifier(tail);
+    }
+
+    "dict[str, Any]".into()
+}
+
+fn optional_struct_inner(
+    struct_ty: &Rc<i_slint_compiler::langtype::Struct>,
+) -> Option<&i_slint_compiler::langtype::Type> {
+    let name = struct_ty.name.as_ref()?;
+    let tail = name.as_str().rsplit("::").next().unwrap_or(name.as_str());
+    let tail_lower = tail.to_ascii_lowercase();
+    if !tail_lower.starts_with("optional") {
+        return None;
+    }
+
+    if let Some(value_ty) =
+        struct_ty.fields.get("value").or_else(|| struct_ty.fields.get("maybe_value"))
+    {
+        return Some(value_ty);
+    }
+
+    struct_ty.fields.values().next()
+}
+
+fn function_to_python_hint(function: &Rc<i_slint_compiler::langtype::Function>) -> String {
+    let args: Vec<String> = function.args.iter().map(type_to_python_hint).collect();
+    let return_type = type_to_python_hint(&function.return_type);
+
+    if args.is_empty() {
+        if function.return_type == i_slint_compiler::langtype::Type::Void {
+            "Callable[..., Any]".into()
+        } else {
+            format!("Callable[[], {}]", return_type)
+        }
+    } else {
+        format!("Callable[[{}], {}]", args.join(", "), return_type)
+    }
+}
+
+#[gen_stub_pyclass]
+#[pyclass(module = "slint")]
+#[derive(Clone)]
+pub struct PyPropertyInfo {
+    #[pyo3(get)]
+    pub name: String,
+    #[pyo3(get)]
+    pub python_type: String,
+}
+
+impl PyPropertyInfo {
+    fn new(name: String, ty: &i_slint_compiler::langtype::Type) -> Self {
+        Self { name, python_type: type_to_python_hint(ty) }
+    }
+}
+
+#[gen_stub_pyclass]
+#[pyclass(module = "slint")]
+#[derive(Clone)]
+pub struct PyCallbackParameter {
+    #[pyo3(get)]
+    pub name: Option<String>,
+    #[pyo3(get)]
+    pub python_type: String,
+}
+
+impl PyCallbackParameter {
+    fn new(name: Option<SmolStr>, ty: &i_slint_compiler::langtype::Type) -> Self {
+        let name = name.and_then(|n| if n.is_empty() { None } else { Some(n.into()) });
+        Self { name, python_type: type_to_python_hint(ty) }
+    }
+}
+
+#[gen_stub_pyclass]
+#[pyclass(module = "slint")]
+#[derive(Clone)]
+pub struct PyCallbackInfo {
+    #[pyo3(get)]
+    pub name: String,
+    #[pyo3(get)]
+    pub parameters: Vec<PyCallbackParameter>,
+    #[pyo3(get)]
+    pub return_type: String,
+}
+
+impl PyCallbackInfo {
+    fn new(name: String, function: &Rc<i_slint_compiler::langtype::Function>) -> Self {
+        let mut parameters = Vec::with_capacity(function.args.len());
+        for (idx, arg_ty) in function.args.iter().enumerate() {
+            let arg_name = function.arg_names.get(idx).cloned();
+            parameters.push(PyCallbackParameter::new(arg_name, arg_ty));
+        }
+        Self {
+            name,
+            parameters,
+            return_type: type_to_python_hint(&function.return_type),
+        }
+    }
+}
+
+#[gen_stub_pyclass]
+#[pyclass(module = "slint")]
+#[derive(Clone)]
+pub struct PyFunctionInfo {
+    #[pyo3(get)]
+    pub name: String,
+    #[pyo3(get)]
+    pub parameters: Vec<PyCallbackParameter>,
+    #[pyo3(get)]
+    pub return_type: String,
+}
+
+impl PyFunctionInfo {
+    fn new(name: String, function: &Rc<i_slint_compiler::langtype::Function>) -> Self {
+        let mut parameters = Vec::with_capacity(function.args.len());
+        for (idx, arg_ty) in function.args.iter().enumerate() {
+            let arg_name = function.arg_names.get(idx).cloned();
+            parameters.push(PyCallbackParameter::new(arg_name, arg_ty));
+        }
+        Self {
+            name,
+            parameters,
+            return_type: type_to_python_hint(&function.return_type),
+        }
+    }
+}
+
 #[gen_stub_pyclass]
 #[pyclass(unsendable, weakref)]
 pub struct ComponentInstance {

api/python/slint/lib.rs

@@ -180,6 +180,10 @@ fn slint(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<brush::PyBrush>()?;
     m.add_class::<models::PyModelBase>()?;
     m.add_class::<value::PyStruct>()?;
+    m.add_class::<interpreter::PyPropertyInfo>()?;
+    m.add_class::<interpreter::PyCallbackParameter>()?;
+    m.add_class::<interpreter::PyCallbackInfo>()?;
+    m.add_class::<interpreter::PyFunctionInfo>()?;
     m.add_class::<async_adapter::AsyncAdapter>()?;
     m.add_function(wrap_pyfunction!(run_event_loop, m)?)?;
     m.add_function(wrap_pyfunction!(quit_event_loop, m)?)?;

api/python/slint/pyproject.toml

@@ -24,10 +24,12 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Application Frameworks",
   "Topic :: Software Development :: User Interfaces",
   "Topic :: Software Development :: Widget Sets",
-  "Programming Language :: Python",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3.10",
 ]
+dependencies = [
+    "libcst>=1.8.5",
+]
 
 [project.urls]
 Homepage = "https://slint.dev"