13 ms·

Show HN: Slint – A declarative UI toolkit for embedded and desktop

• samwillis 3y ago
  Looks really nice! I used to work in the Medical Device, Bio Tech & consumer device space (~10 years ago), good toolkits for building embedded interactive UIs were few and far between. The idea of having one codebase for both an embedded UI on a low spec device and for a mobile app is really compelling. I could see a dev kit, based on an existing dev-board and screen, running JS with bindings to this, as a great way to do rapid prototyping and development. Then being able to take that and optimise down to lower cost production hardware. As with all these toolkits, when it comes to the web and doing rendering via a HTML Canvas you end up with accessibility problems. Not though a fault of not considering it, but its not something you have to consider for an embedded device at all (or you do but it's built from scratch for that specific device). Unfortunately the APIs are just not there yet on the web platform to open up accessibly of these sort of UIs. I suspect the key selling point of the web version is building demos and simulators for design validation. It makes it super easy to distribute to projects stakeholders and focus groups. We did something in that area for an early version of the UI for the first version of the Bosch Robot Lawnmower, we had demo hardware on the mower, and a UI simulator written in JS. Both used the same custom built UI specification system, so we could iterate the design and demo it via the web, then built it into the embedded software for the hardware prototypes.
  • ogoffart 3y ago
    Thank you for your feedback! We are aware of the issue regarding accessibility when rendering via HTML Canvas on the web platform. Our web version of Slint is mainly, as you guessed, designed for demo purposes. While it would be possible to write a backend that uses the DOM, we haven't done it yet because our focus is currently on embedded and desktop.
    • mwcampbell 3y ago
      At some point I'm planning to work on a web backend for AccessKit. I know that creating a parallel DOM for canvas-based web applications doesn't solve all accessibility problems, but it'll at least be better than nothing.
• nologic01 3y ago
  The GUI space is crying out for more workable approaches so fresh takes are more than welcome. But going through the website the comparison with other existing options (Qt, Electron etc) is mainly schematic one-liners, good for marketing but not particularly informative. Curious also if there are plans for Python API's
  • ogoffart 3y ago
    Thank you for your comment! I acknowledge that the comparisons on our webpage footer is primarily for marketing and SEO purposes. This is inspired by the equivalent content on websites like figma.com. The intention is to highlight Slint's unique selling points without delving into extensive discussions about other frameworks. And yes, we do have plans for Python, that would actually be the next language we want to make bindings for.
• Kelteseth 3y ago
  Nice to see that Qt finally gets some competition! The pricing alone is a no-brainer. Now the only thing I'm missing from the demos is smooth scrolling :)
  • pjmlp 3y ago
    Not to diminish Slint authors work, but it is still far from being Qt competition, given the current state of accessibility, IDE integration, or graphical tooling for UI/UX designers.
    • madnirua 3y ago
      Disclaimer: I work for Slint Indeed we are actively working on all of those topics: Accessibility support in Slint is improving. We just merged the initial AccessKit integration into our winit backend -- https://github.com/slint-ui/slint/pull/2865 https://github.com/slint-ui/slint/pull/2865 IDE integration - our VSCode extension is pretty stable these days (https://slint.dev/get-started#vscode https://slint.dev/get-started#vscode) and we also support integrating into other IDEs via LSP (https://slint.dev/get-started#other-ide https://slint.dev/get-started#other-ide) Graphical tooling for UI/UX designers - our current prototype https://slintpad.com https://slintpad.com needs more work to become an easy Drag n'Drop editor for UI/UX designers -- but we are on the right path to achieve that :)
    • ogoffart 3y ago
      Slint is already a viable alternative to Qt, as evidenced by users actively choosing us over Qt. While Qt is more mature in many areas with its two decades of development and large team, Slint is already good enough for some use cases. And as a young framework, we naturally strive to improve. By the way, when it comes to IDE integration, our VSCode extension and LSP server, which includes live preview, put us on par with Qt's.
      • pjmlp 3y ago
        Sorry but that isn't the same thing, you're even reckon that is only some use cases, not all of them. Using VSCode is hardly comparable to QtEditor alongside Qt Design Studio. So yeah it might be a viable alternative to those that aren't even aware of what a full installation of Qt brings in the box. While I don't doubt Slint will eventually reach that level, we are comparing 1.0 release with 6.5 and related tooling. By the way, madnirua's answer was more in line with the reality and it was appreciated.
• kookamamie 3y ago
  The widgets examples do not look good, unfortunately. Let me elaborate: they seem aliased (everything looks like sampled with nearest neighbor), spacing is non-uniform and overall the style chosen looks somewhat outdated.
  • ogoffart 3y ago
    Just to clarify: are you talking about the image next to Desktop in https://slint.dev/use-cases#desktop-applications https://slint.dev/use-cases#desktop-applications ? Indeed, we'll improve on that. Thanks for your feedback! For the story, we initially had screenshot of an actual commercial desktop app, but we were asked to remove it by the author until the app is actually released. So we went with that set of of widget instead, which is a prototype of the Cosmic style for Pop!OS) Edit: We changed the image. (for reference, the previous image was https://slint.dev/assets/img/cosmic_de_popos_light.png https://slint.dev/assets/img/cosmic_de_popos_light.png )
    • kolektiv 3y ago
      I am not a designer (not for 20 years now) but that desktop image (rotating gif of different styles) is not a good advert. There are many, many layout issues with those that I would really spend time to try and make "default" look right out of the box (and in line with platform HID guidelines). I am a Rust developer, and I think Slint could be amazing, but those things will put off people who are driven by design quality.
      • madnirua 3y ago
        Thanks for the feedback. We will try to get some designers to improve the widget gallery examples.
• tyfon 3y ago
  Nice! I have been using libQt since the last millennium for different projects, this looks more like how I use it as I never really liked QML. But the comparison page vs qt is a bit thin, what do I gain here and how do the features compare? It works be nice if the page was more fleshed out in that respect. It's so refreshing when new stuff comes out for native and not just web web web!
  • madnirua 3y ago
    Thanks :) Since Qt is a much broader toolkit, we are considering of writing dedicated blogs to do an objective comparison between the two toolkits on the GUI part only.
    • joezydeco 3y ago
      Please do! And, speaking as a Qt programmer, address the biggest pain points that Qt user have. Number one: get a virtual keyboard that supports the biggest world languages without a commercial license. That would make me an instant convert.
      • madnirua 3y ago
        Thanks :) For the short term, we have an example that some of our community users and commercial customers a using to build their custom virtual keyboard https://github.com/slint-ui/slint/blob/master/examples/virtual_keyboard/README.md https://github.com/slint-ui/slint/blob/master/examples/virtu...
        • joezydeco 3y ago
          I'll try it out, thanks. I'm pretty fed up with Qt and I'm getting kind of excited to start experimenting with this.
• fodkodrasz 3y ago
  Looks nice, but actually the per/appliance pricing could be a bit clearer, I hate the Call Us type pricing pages, that is usually where I rather look for the competition... (Just had some hardship with finally getting an atrociously expensive quote after spending workdays of providing the needed inputs to a HW vendor)
  • madnirua 3y ago
    Disclaimer: I work for Slint I suppose you are referring to the "Embedded Add-on per application" pricing? At least the non-commercial use is hopefully clear :) Yes, we need find a better way to show the pricing there since it's dependent on 2 variables - volume and type of embedded system. Maybe some sort of a online calculator?
    • __forward__ 3y ago
      What exactly is a 'user'? Literally one device running the application? In that case the pricing does seem a bit steep in a small business context.
      • madnirua 3y ago
        A user is a person (eg. a developer or a designer etc.) using Slint to build the GUI.
        • nicce 3y ago
          Ahh, it makes this much more reasonable. The enterprise pricing made me thought at first that the cost is per application user. (Making enterprise lisence more appealing) … of course per end-user pricing would be way too expensive.
          • madnirua 3y ago
            We changed the term from "User" to "Seat" and added an entry in the FAQ section to avoid confusion.
• peepee1982 3y ago
  I understand too little about GUI Toolkits to have a strong opinion on the technical merits, but as a music fan, I appreciate the name.
  • madnirua 3y ago
    Thanks.. Probably we should name our major releases after some of the band's titles :)
• meepmorp 3y ago
  Is it named after the band?
  • madnirua 3y ago
    Just a nice co-incidence :) The toolkit was initially named SixtyFPS and was renamed to Slint last year --https://slint.dev/blog/sixtyfps-becomes-slint https://slint.dev/blog/sixtyfps-becomes-slint The name comes from our design goals - Straightforward, Lightweight, Intuitive, Native Toolkit.
    • meepmorp 3y ago
      Well, I'm still gonna listen to Spiderland because you reminded me, so thanks for everything.
      • geekamongus 3y ago
        Tweez is my favorite album of theirs, though Spiderland is excellent.
        • HDThoreaun 3y ago
          Scorching take. Tweez is nowhere close to spiderland. Now hurry up and get me some new headphones Steve, they're fucked.
  • DontchaKnowit 3y ago
    If youre reading this, go listen to spiderland by slint. Awesome and super unique album
    • lbres 3y ago
      I’ve always hoped that HN was a place that appreciated music like Slint, now I have my answer.
• serial_dev 3y ago
  The comparison sections are very confusing. It says you will compare your UI toolkit with, for example, Flutter and then there is no comparison there at all. I thought the site is broken on mobile, I tried different browsers, etc, because the comparison was just not there. If you don't have any real content there because you don't want to start a flame war, you could try something like what the Flutter team did, they have an "onboarding guide" for XYZ developers that builds upon things you already learned in other frameworks and explains the key differences without coming off as hostile towards the other frameworks. https://docs.flutter.dev/get-started/flutter-for/react-native-devs https://docs.flutter.dev/get-started/flutter-for/react-nativ... I'm a Flutter developer by day and Rust enthusiast by night, and I'm looking for a "good enough" Flutter alternative that uses Rust.
  • pzo 3y ago
    Not a Flutter Dev, but have you tried 'flutter_rust_bridge' [0]. Seems provide some interop between flutter and rust and looks like a popular and active project. I'm native mobile dev and just curious about this kind of interop myself. If it's seamless then looks like good balance to do mobile front-end in flutter and mobile backend in rust. [0] https://github.com/fzyzcjy/flutter_rust_bridge https://github.com/fzyzcjy/flutter_rust_bridge
    • tracker1 3y ago
      Cool... was just thinking one could use flutter's web target with tauri's interop and host model.
  • madnirua 3y ago
    Thanks.. This is a nice reference for an onboarding guide.. We could add a similar section to our documentation page https://slint.dev/docs https://slint.dev/docs
  • nologic01 3y ago
    Made a similar comment about the comparison pages, which is a simple and factual statement yet was downvoted immediately by (pressumably) people with a stake in the project. Does not reflect well... Detailed and unbiased comparisons are extremely useful but also are hard (and costly) to do. Don't promise them if you can't deliver.
• davidhyde 3y ago
  I just spent the last two weeks choosing an embedded ui framework and then building out a little demo to test out its capabilities. I settled on Slint and have been very impressed with the design of the domain specific language they came up with. It’s small, simple, powerful and easy to learn IMO. The vs code extension for real time gui feedback is amazing. I’ve used swift ui before and Slint is as much of a joy to use. This is a breath of fresh air compared to Microsoft’s Windows Presentation Foundation that took me years to master. My only concern is optimising for binary size. My little microcontroller only has a measly 1MB of flash storage and I’m already at 900kb on a 15 screen app with no icons or images. It would be nice to know what actually uses up all that space (as little as it is). Perhaps I need to use ui element virtualisation or something. Edit: 1kb of flash -> 1MB of flash
  • nicce 3y ago
    Out of curiosity, 1kb of flash storage sounds quite tiny for a chip which is expected to provide GUI capabilities. Can you provide more information about the context?
    • davidhyde 3y ago
      Typo, I meant 1MB. The actual specs are 1MB flash, 564KB sram and around 500Mhz mcu speed. I’m using the STM32H735G-DK development board which comes with a few bits extra to drive a 4.2” lcd screen directly. There are already demos for it in the Slint repo which is why I chose that hardware in particular.
  • ogoffart 3y ago
    Thank you for your comment and feedback! I'm glad to hear that you have chosen Slint for your embedded UI framework and have been impressed with its design and ease of use. Feel free to post on Github for issues or discussions. I assume you meant 1Mb of flash and not 1kb of total flash :-) We might find some way to optimize the generated code to reduce the binary size further.
    • davidhyde 3y ago
• denysvitali 3y ago
  Funny how they claim the toolkit is responsive, but then their website isn't. The "Used by" section overflows and basically breaks the whole website.
  • madnirua 3y ago
    Probably because we are using HTML and CSS instead of Slint :) Jokes aside .. which browser and device combo are you using.. We can adjust the css accordingly. Thanks.
    • denysvitali 3y ago
      Pixel 7, Chromium. I think the issue is with one of the logos at the bottom
• danielscrubs 3y ago
  An UI framework in 2023 needs two things: one line animations and a gorgeous starter template. The inconvenient truth is that there are way more good coders than there are good designers so coders need all the help they can get to sell their product and make good ux choices. Any comments on how it compares on those fronts?
  • ogoffart 3y ago
    We do have one line animations [1], we do have starter templates[2]. But not sure what you call "gorgeous". I 100% agree with the need of good designers. [1] https://slint.dev/docs/slint/src/reference/animations https://slint.dev/docs/slint/src/reference/animations [2] https://github.com/slint-ui/?q=template&type=all&language=&sort= https://github.com/slint-ui/?q=template&type=all&language=&s...
• orra 3y ago
  The examples start up promisingly fast. Faster than Uno, IMHO, and waaay faster than Qt (on WebAssembly I mean). Great to see competition in this space; I'm sure they'll all benefit in the long run.
• Alifatisk 3y ago
  "Achieve low footprint and minimal resource consumption. The Slint runtime fits in less than 300KiB RAM..." Well done! This is exactly what we should be better at, ship less bloat and set a higher standard.
• andsoitis 3y ago
  Correct and complete text handling is hard. Does Slint handle (did a cursory search in the docs but couldn't find anything that hints at an answer): * multi-line text * languages that use non-Latin characters, as well as mixing them in the same control * RTL and maybe vertical layout
  • ogoffart 3y ago
    Correct text handling is indeed a challenging task, especially to get all keyboard shortcut to edit and input methods. While we strive to improve our text handling capabilities, we are not perfect yet. Slint does handle multi-line text and languages that use non-Latin characters. However, we currently do not support vertical layouts.
    • criddell 3y ago
      How’s accessibility? Does Slint play well with things like screen readers?
      • tronical 3y ago
        We do have initial support for screen readers. That’s using accesskit, or Qt when using the Qt backend. It’s still basic, some controls like text input need work, or customizing the focus chain. Building blocks are there and will need further polish.
• deleted 3y ago
  [deleted]
• zoogeny 3y ago
  There is often a criticism of Javascript, that new frameworks seem to appear every week. But it honestly feels like every week on HN there is a new Rust UI project showing up. Whether it is some new HTML/web thing, a native app thing, a TUI thing, etc. Don't get me wrong, I think that is the sign of a very healthy ecosystem. I am just curious how the Rust evangelists will spin this. Somehow this constant churn on the Javascript side is worthy of snide, satire and ridicule. IMO, UI development is deceptively hard. Rendering scalable graphics efficiently is hard enough. Creating a good layout engine and a set of reliable basic controls is even more difficult. But managing interfaces seems to scale quadratically with the number of controls, views, states, etc. I see programmers, over and over, underestimate how difficult of a task managing that complexity can be. This complexity leads to difficult to use libraries/framework/platforms. It also leads naive and ambitious developers to believe they can do better. This leads to more and more new libraries/frameworks/platforms.
  • duped 3y ago
    It's a somewhat hot area of development and there isn't a clear winner yet, so of course there are new projects all the time.
  • kibwen 3y ago
    > Somehow this constant churn on the Javascript side is worthy of snide, satire and ridicule. In my experience it is frontend devs, not backend devs, who are most harsh on Javascript's procession of UI frameworks. Rust users are more than happy to take inspiration from Javascript UI frameworks, if for no other reason than the reactive/declarative approach is a better fit for Rust than the prevailing inheritance-heavy/object-oriented approach of Qt and GTK.
  • zemo 3y ago
    it’s a different situation though: very few people have shipped guis in Rust, so the Rust projects are largely greenfield, while a lot of JavaScript front ends are legacy apps.
  • a_humean 3y ago
    All of these rust libraries and frameworks are in their infancy and there are no clear winners yet. Its probably less of a sign of a healthy ecosystem, and more of a sign of an immature ecosystem. There are a few projects that seem promising, but all of that could be invalidated by next week. Meanwhile in the js ecosystem things are both incredibly stable and also in flux. All of the usual suspects are still around, but competing in ways intergrate both server and client rendering as seamlessly as possible. There is also some movement around introducing optimising compilers - see solid and svelte. But its probably safe to say, ignoring the tooling churn going on with Rust, Go, and Zig seemingly systematically replacing all js tooling like for like, things are pretty stable when it comes to js ui libraries.
• ealhad 3y ago
  This looks really neat, I played with it a bit and the DSL is well thought out. One thing I can't figure though: how do we set default values for internal Struct? Said default values are mentionned in the documentation (here: <https://slint.dev/releases/1.0.2/docs/slint/src/reference/types#conversions https://slint.dev/releases/1.0.2/docs/slint/src/reference/ty...>). // ok even if a is missing, it will just have the default value
  • ogoffart 3y ago
    Currently the default is just whatever empty value for that type (so 0 or "") But since this is something that was asked before, I created an issue: https://github.com/slint-ui/slint/issues/2936 https://github.com/slint-ui/slint/issues/2936
    • ealhad 3y ago
      Neat!
• nazgulsenpai 3y ago
  I'm a total laymen on the embedded side, and as such I think this looks great and the GPL and permissive licensing options are a very welcome and (IMO) fair way to engage and empower the community.
• monk_e_boy 3y ago
  You should give us educators a free license :) I'd use this in my classes if I could. I'm keen to use it with c++ and rust
  • vbarrielle 3y ago
    It looks like you can use the GPLv3 license for this use case.
• seren 3y ago
  Do you support any kind of integration with Vxworks 7 on some platform ? Vxworks has some Rust support so I wonder if you already had some integration with vxworks drivers
  • madnirua 3y ago
    We investigated integration VxWorks as part of a customer request and we concluded that all the required hooks exist to support Slint.
    • seren 3y ago
      Thanks for the answer !
• n8henrie 3y ago
  > Create your application under MIT, BSD, Apache 2.0 or any of the other GPLv3 compatible licenses, provided that the complete work is made available under the GPLv3. > Create your application under a license of your choice, open-source or proprietary, provided that the application includes proper attribution to Slint and retains copyright notices. I've listened to at least one (or two?) podcasts on slint, and I'm still not sure that I understand the license options, which makes me hesitate to invest time to learn. I usually use the MIT license. Is the first license above compatible with MIT, without requiring forks (of my project) to GPL3 their code? Does the latter license mean I can closed-source and commercialize my app and just include a shout-out to Slint and I'm good? (EDIT: if so, why would anyone choose the potentially expensive commercial option?)
  • ogoffart 3y ago
    Forks of your project do not require open-sourcing their code if they adhere to the terms of the royalty-free license, which include attributions and excluding usage on embedded devices. (Alternatively, they can get a paid license) > why would anyone choose the potentially expensive commercial option The paid option is for those using Slint in embedded devices (which is not permitted by the royalty-free license) or for those who prefer not to include attribution to Slint in their program.
• nyanpasu64 3y ago
  The toolkit still seems quite incomplete for desktop use (as opposed to embedded/appliance UIs), as it doesn't support menu bars in an issue open since 2020: https://github.com/slint-ui/slint/issues/38 https://github.com/slint-ui/slint/issues/38
  • ogoffart 3y ago
    A comprehensive toolkit like Slint is an enormous and ambitious task. We prioritize feature implementation based on user demand and needs. As of now, we haven't received any specific requests from users for the menu bar feature, but we know it is important (we filled the issue ourselves)
  • ShadowBanThis01 3y ago
    What is a "menu bar?" Something other than a regular application menu?
    • nyanpasu64 3y ago
      The toolkit doesn't support regular application menus or right-click menus.
      • ShadowBanThis01 3y ago
        That's a pretty big problem.
• gregulrajani 3y ago
  The band is not that bad as well https://en.m.wikipedia.org/wiki/Slint https://en.m.wikipedia.org/wiki/Slint
• TobyTheDog123 3y ago
  >Attribution to Slint Mmmm no thanks, I'll pass. While I'm looking for a Flutter alternative, this seems like a trap.
  • ogoffart 3y ago
    We are not a charity and aim to operate on a sustainable development model. While we offer paid and GPL licensing options, we also provide a free-of-charge license that only requires attribution. If you are unwilling to provide even attribution, then Slint may not be the right choice for you.
    • TobyTheDog123 3y ago
      Oh it's certainly not for me, no question about it. Yet, it's curious that you compare Slint to LVGL/Flutter/Electron (I don't know about Qt) when none of them have this intrusive requirement. --- >What's intrusive about it? (a) Display the AboutSlint widget in an "About" screen or dialog that is accessible from the top level menu of the Application. (b) Display the Slint attribution badge on a public webpage, where the binaries of your Application can be downloaded from, in such a way that it can be easily found by any visitor to that page. (c) You may not remove or alter any license notices (including copyright notices, disclaimers of warranty, or limitations of liability) contained within the source code form of the Software. (d) You allow SixtyFPS to use your Application on the website and in advertising materials of SixtyFPS as a reference and to display your logo and trademark for this purpose. --- Please don't pretend like a/b/d aren't big asks by saying "you wont even provide attribution?"
      • random78965 3y ago
        Not a dev, but I've often seen software that acknowledge their dependencies in About sections and on their websites. Is that particularly intrusive? Especially given that you could always use the GPL too if you want.
        • ShadowBanThis01 3y ago
• codethief 3y ago
  The in-browser demos (using WebAssembly) are surprisingly fast and responsive (very different from the Flutter demos that I remember). Very cool! Also, I just realized I had checked out this project before when it was still called SixtyFPS, https://slint.dev/blog/sixtyfps-becomes-slint https://slint.dev/blog/sixtyfps-becomes-slint . Maybe it would make sense to mention the name change in your post.
  • ogoffart 3y ago
    It has been over a year since we renamed the project. We previously had a note on every page with the former name. But the new website design no longer includes this note.
• CyberDildonics 3y ago
  Ignoring for a second that "Slint" is only slightly better than "60fps" as a name for a GUI library, I think using a custom domain specific language for configuration is a giant mistake. It really is not difficult to just call functions to set values. Laying out GUI components is also rarely what takes time when doing GUI programming. A brand new custom domain specific language has almost no benefits but has huge downsides like having to learn brand new syntax, complete with error messages and debugging. Then you probably have to change GUI values dynamically anyway inside your program. All of this is on top of the added bloat, which itself is strange for a 'embedded usage'. I think a lot of newer GUI libraries would be better off porting FLTK to work on their platform, it is very simple and easy to understand underneath.
  • ogoffart 3y ago
    DSLs are not inherently more difficult to learn than API and conventions of a complex GUI library. DSL offer benefits in terms of expressiveness and conciseness. The focus in UI programming is on rapid iteration and immediate results, which can be facilitated by a live preview in the IDE made possible by a declarative DSL
    • CyberDildonics 3y ago
      DSLs are not inherently more difficult to learn than API and conventions of a complex GUI library In theory maybe, in practice the indirection and extra layer of syntax, error handling, documentation and edge cases mean this is not true. Also this is an assertion without any evidence. DSL offer benefits in terms of expressiveness and conciseness. Prove it. The focus in UI programming is on rapid iteration and immediate results I have never thought that setting up values through functions was not rapid. It has never been a bottleneck or time sink when making a GUI. Unfortunately, using custom markup languages that don't work like they say they should has been a time sink. which can be facilitated by a live preview in the IDE made possible by a declarative DSL My experience is that this is very minor in terms of overall utility and doesn't actually require a custom markup language.
• irq-1 3y ago
  Do I need to use rust or cpp? Can I work in js only? I like the slint layout files and the viewer. Are you planing a C interface?
  • ogoffart 3y ago
    You don't need c++ or rust if you want to work with JS. (although right now you will need a rust compiler to compile the binary, but we want to ship binaries in the future) We are considering a C interface, but given we already have a C++ interface, we don't see much gain in having a C interface compared to the effort to maintain it.
• david_shi 3y ago
  Unrelated, but a song by the band was in the 'BlackBerry' movie. https://www.youtube.com/watch?v=CuqEpjcBfaU https://www.youtube.com/watch?v=CuqEpjcBfaU
• tracker1 3y ago
  Wether it's fair or not.. I generally compare any given UI framework/toolkit to mui.com (Material-UI) component library. They've solved a lot of the issues I've had, nice to work with and in general really well-rounded components. Would love to see an equivalent with Yew or similar, maybe integrated like Tauri. In the end, I think that accessibility is a really hard thing to get right. As are the base components that are generally needed for applications. This is a nice start, and for lighter/embedded it could be nice. I'm not sure that I'd reach for this ahead of Flutter, React(-Native) or alternatives that are more polished for general use though.
• captainmuon 3y ago
  I'm always happy when a new GUI toolkit comes out and Slint looks really well done, especially if you like QML. I could imagine using it if I do another embedded or kiosk application. However, I find the modern flavor of "declarative" is not really for me. QML, Slint, and to some degree XAML and SwiftUI are all like this. They mix widgets with layout elements and presentational elements (like rectangles). There is no separation of content and style. Another smaller problem is that the initial layout is done in the markup language, but any runtime additions have to be done in another language (if at all possible). In my ideal GUI, you could say in code "give me a detail-item view" or "this pane shows the detail of the selected item from this pane", and then have it layed out according to platform standards, possibly completely different on iOS or on Windows. But then you could go in and customize the placement and look&feel of every element with CSS if needed. Either applying platform styles ("default inset border") or completely custom styles.
  • pie_flavor 3y ago
    Separating content and style does not really have a purpose in GUIs. A lot of people who come from HTML assume it does because HTML does it, but HTML does it because it's for documents, where it does have a purpose. It's got nothing to do with declarativeness; everyone does the same thing because it works and the other way doesn't solve problems. The only non-DOM-based library I know of to use separate stylesheets is JavaFX and it's one of the biggest reasons people hate it.
• aembleton 3y ago
  The link to Javascript at the bottom of this page is broken: https://slint.dev/releases/1.0.2/docs/slint/ https://slint.dev/releases/1.0.2/docs/slint/. It goes to https://slint.dev/releases/1.0.2/docs/nodejs/ https://slint.dev/releases/1.0.2/docs/nodejs/ which gives a 404.
  • madnirua 3y ago
    Thanks for reporting. Will fix that.
  • madnirua 3y ago
    Here is the correct link https://slint.dev/releases/1.0.2/docs/node/ https://slint.dev/releases/1.0.2/docs/node/
• Sophistifunk 3y ago
  What's the catch? There's always a catch, like "turns out it's just WebView" or "turns out only the android and Linux CDE implementations actually exists" or "call us for pricing"
  • WorldMaker 3y ago
    Looks like "Call us for pricing": > Free for non-commercial use. > For commercial use, the runtime fee is based on volume and type of embedded system.
    • madnirua 3y ago
      We plan to add a pricing calculator later, replacing “Call us for pricing “
• WhereIsTheTruth 3y ago
  If you need something written in C and very tiny, I recommend LVGL https://lvgl.io/ https://lvgl.io/ Fits easily in 128kb boards