Other Python declarative native GUI projects

[jamesdbrock]

RE-WX

https://github.com/chriskiehl/re-wx

re-wx is a library for building modern declarative desktop applications. It's built as a management layer on top of WXPython

PUI

https://github.com/buganini/PUI

PUI is a declarative UI framework with two-way data binding

Reacton

https://github.com/widgetti/reacton

A way to write reusable components in a React-like way, to make Python-based UI's using the ipywidgets ecosystem

https://maartenbreddels.medium.com/advance-your-ipywidget-app-development-with-reacton-6734a5607d69

The use_effect and use_state functions in Reacton are called “hooks”

Great API design, but sadly not native — only for Jupyter iPyWidgets.

Collagraph

https://github.com/fork-tongue/collagraph

Python interfaces in a declarative manner with plain render functions, component classes or even single-file components using Vue-like syntax

pyreaqtive

https://github.com/polfeliu/pyreaqtive

pyreaqtive is a framework for developing applications in pyqt/pyside with reactive programming

Alfort

https://github.com/ar90n/alfort

simple and plain ELM-like interactive applicaiton framework for Python

Flet

https://github.com/flet-dev/flet

With Flet you just write a monolith stateful app in Python only and get multi-user, realtime Single-Page Application (SPA).

Flet seems promising, because Flet is based on Flutter, and Flutter is declarative. But Flet made some bad architectural choices, and is imperative. flet-dev/flet#55 (comment)

Kivy

https://github.com/kivy/kivy

https://kivy.org/doc/stable/guide/lang.html#concept-behind-the-language

the KivyMD library allows you to write Python code in a declarative style. Just as it is implemented in Flutter/Jetpack Compose/SwiftUI.

Declarative programming style in Python code in the KivyMD library is an experimental feature. Therefore, if you receive errors, do not hesitate to create new issue in the KivyMD repository.

https://kivymd.readthedocs.io/en/1.0.1/behaviors/declarative/index.html#declarative-style-with-python-code

Castella

https://github.com/i2y/castella

https://speakerdeck.com/i2y/a-cross-platform-pure-python-declarative-ui-framework

Enaml

https://github.com/nucleic/enaml

• A declarative programming language, with a Pythonic flavour.
• Dozens of widgets, ready to go out-of-the-box (built on Qt).

DearPyGui

https://github.com/hoffstadt/DearPyGui

it uses the immediate mode paradigm

https://github.com/nix-community/nur-combined/blob/master/repos/some-pkgs/pkgs/dearpygui/default.nix

Python Concur

https://github.com/potocpav/python-concur

Concur is a Python GUI framework based on synchronous generators.

It is a port of Concur for Purescript, implemented on top of the Dear ImGui C++ UI library.

LayoutX

https://github.com/Bomberus/LayoutX

Declarative tkinter UI with reactive data binding

PynamicUI

https://github.com/zacharie410/PynamicUI

create dynamic web-like UIs using a declarative syntax
PynamicUI requires the CustomTkinter library.

[jamesdbrock]

Hi @buganini and @berendkleinhaneveld !

There are too many of these projects. Let’s try to combine our efforts? What do you think about Edifice?

[jamesdbrock]

The with syntax doesn't really allow for that:

BTW: if this is not the appropriate place to share these thoughts

Thanks for your thoughts, that's very interesting. (This is exactly the kind of conversation that I want to have here.)

[buganini]

About the VDOM diffing, To prevent diffing a huge VDOM, PUI has a subview design and my worst thought is to construct and diff VDOM in C++ ;P

[berendkleinhaneveld]

I'm interested in how that subview design works, will take a look at it soon.
I've also been thinking about diffing in C/C++/rust, but I'm afraid that there is going to be way too much overhead from going in and out of python context for it to provide any real benefits...
I've been reading about svelte 5: https://svelte.dev/blog/runes and it links to some interesting articles, also about SolidJS. https://dev.to/ryansolid/a-hands-on-introduction-to-fine-grained-reactivity-3ndf -> in Collagraph we use observ, which is basically a signal lib.

What would be really cool is if we can have a Python project which uses the concepts from Solid. Their JSX template syntax has some tricks which might actually be translatable to a Python version with the with construct.

[maartenbreddels]

I don't think 'DOM' diffing needs to be a problem, as long as you by default assume purity (like React's pure components using memo), and only diff what is needed. Too large components should be avoided by a user, maybe Reacton components are like PUI's subview?.

In solara (which is built on top of Reacton), we introduce reactive variables, which are similar to signals in preact:
https://solara.dev/api/reactive

import solara

counter = solara.reactive(0)

def increment():
    counter.value += 1


@solara.component
def CounterDisplay():
    solara.Info(f"Counter: {counter.value}")


@solara.component
def IncrementButton():
    solara.Button("Increment", on_click=increment)


@solara.component
def Page():
    IncrementButton()
    CounterDisplay()

Where components automatically subscribe to update (i.e. automatically rerender) when the state of a reactive variable changes.

[pushfoo]

I have an update on these earlier points:

Is there a way to integrate it with a GL context?

Render to different frameworks: Qt for windowing/UI, Pygfx for 3D/2D visualizations

The following suggest 3D integration is definitely possible here as well:

1. Elm has (somewhat outdated) WebGL examples
2. I've been updating a pyglet example integrating PySide2/PyQt5-based to familiarize myself with Python's Qt bindings

The QOpenGLWidget the example uses also exists in PySide6. However, there also seems to be a PySide6.Qt3DCore module, which provides more abstractions than pyglet does at the moment.

[jamesdbrock]

Hi @maartenbreddels , I love your Reacton project. I love your choice to call components using a with context manager. And congratulations for implementing Hooks in Python; I believe you’re the first person to do that.

[maartenbreddels]

Thank you @jamesdbrock !
Let's continue at widgetti/reacton#20

[jamesdbrock]

Edifice now has

1. with-statement tree declaration syntax
2. Hooks