Show HN: SixtyFPS – multi-language GUI toolkit for desktop/embedded
sixtyfps.io
sixtyfps.io
Our short term goal is to get involved in a paid project that would require a GUI frontend and where we could make use of this project. If you have any recommendations, or if you know of any such project, we would be happy to hear from you.
The description mentions targeting embedded applications. What's the definition of embedded in this context? I see "several hundred kilobytes of RAM" mentioned - What's a minimal configuration likely to look like?
Just trying to get a feel for the typical embedded application that you'd be targetting. Most of the embedded work I do is with <= 64kb RAM, which I'm guessing is not your target.
It might be helpful if you could perhaps contrast the product with existing (similar?) libraries such as as LVGL[1], uGFX[2] etc.
[1] https://github.com/lvgl/lvgl
[2] https://ugfx.io/
We need to make our description a bit more precise - and we're working on comparisons. In terms of pure RAM usage (as opposed to ROM) in our experience the display resolution contributes a lot to what's left (unless there are dedicated frame buffers). So if you mention <= 64kb RAM, what kind of displays are you typically dealing with?
Generally I think we're aiming a little above LVGL/uGFX in terms of configuration, but also with with a much richer UI / features.
Typically displays with integrated SRAM. To give an example, a recent project used a 480x320x16-bit display and an MCU with 64kb SRAM. The display/drawing buffer took 38kb of that (i.e. 1/8 of the display).
The runtime’s API is available as plain C++ API (only depends on C++ standard library), JS api in node (via neon) and Rust natively (simply a crate). It’s generally rather lightweight in terms of its surface. Instead the focus is on our compiler generating API for the input design files, to make it easy to manipulate properties or feed data models into the UI.
We’re internally using QStyle calls to produce images of controls when selecting that kind of styling at compile time, but that’s entirely encapsulated. The style you see in the wasm demos for example is entirely done using GLES accelerated primitives (such as SDF based anti-aliases rectangles).
The definition of layout is nice, but handling state changes is still imperative. Is there a way to have values update without having to explicitly respond to signals?
On the desktop platform, we can make use of a native style (using the styles from Qt in the current implementation)
As for the handling of the state change, they are not imperative. The values update automatically as the property changes. (For example the text of this button changes when you click it: https://www.sixtyfps.io/editor/?snippet=%0Aimport+%7B+Button... )
Is that the kind of example you were looking for?
I believe the only way to build apps for Remarkable is using QT: https://github.com/canselcik/libremarkable
As for Remarkable, I don't know enough about their platform to know if they are open enough to support other toolkit. But this kind of hardware is totally something we could target.
Really excited to see more competition in this space!