rust-dominator VS solid

They are both async and made for GUI -- in case of rust-signals WebGUI, provided by dominator and MoonZoon.

You shouldn’t ever need to deal with OsString itself on wasm32-unknown-unknown, since that target basically just doesn’t cover functionality that needs it, but the actual situation is genuinely worse than OsString: Rust insists on valid Unicode (as is right and proper), but the web suffers from the affliction of ill-formed UTF-16. If you blindly convert from JavaScript strings to Rust strings, you will encounter data and functionality loss in a few situations, in practice always involving IME (or similar) text entry on Windows. The first bug I filed about this: https://github.com/Pauan/rust-dominator/issues/10, and you can follow further links if you’re interested. IE and Edge used to be largely immune to this, but IE is dead and I suppose Edge will have regressed in this way with the Chromium migration, since the bug filed in Chromium a few years ago <https://bugs.chromium.org/p/chromium/issues/detail?id=949056> has languished. (Firefox too, with <https://bugzilla.mozilla.org/show_bug.cgi?id=1541349>.) In the worst-case scenario, careless use like was the case in rust-dominator will mean that some users typing with particular software in a language that’s outside the Basic Multilingual Plane will not be able to type anything.

One comparison I'm missing , which I think provides quite a nice solution in Rust, is the signals based approach popularized by Solid JS and implemented in Rust by sycamore and earlier by dominator.

Missing support for characters beyond U+FFFF is the main problem caused by surrogates (their existence, even if indirect)—it normally comes of some kind of UCS-2/UTF-16 confusion. It’s not fair to disqualify them. The only (class of) case that I’m aware of for a long time where it’s not linked to that is with MySQL’s idiotic utf8 → utf8mb3 type.

You may not have encountered such bugs, but I’m very familiar with surrogate-related bugs, because I use a Compose key extensively. I haven’t been using Windows for the last year, but from time to time I would definitely encounter bugs that are certainly due to surrogates. On the web, I found bugs a few times, all but once in Rust WebAssembly things, such as https://github.com/Pauan/rust-dominator/issues/10. And even now I’m back on Linux, I know of one almost certainly surrogate-related bug: I can’t type astral plane characters in Zoom at all; pretty sure I had this problem back on Windows, too. Copy and paste, sure, but type, no, they become REPLACEMENT CHARACTER.

The history is unfortunate but I strongly refute that they had not much choice. UCS-2 should have been abandoned as a failed experiment. Certainly there had been significant investment into it in the last few years, but with the benefit of hindsight, switching to UTF-8 (which was invented before they decided on surrogates) would have made everyone’s life much easier, especially given its ASCII-compatibility.

Ah, BOM characters. Haven’t seen one in years. Good riddance.

I really don't understand why everyone jumps to Yew when it comes to front-end development. Dominator is a far cleaner and more Rust-orientated approach to building front-end apps. I have worked with both and I feel that Yew adds a lot complexity/forces a lot of design philosophies but gives very little back in terms of advantages.

Hi, I've just released a major new version of Silkenweb. It's a signals based web framework like Dominator or Sycamore, but with the emphasis on plain rust syntax rather than a macro DSL.

Check out the alternatives without vdom, especially Dominator https://github.com/Pauan/rust-dominator. It’s faster than nearly all JS frameworks. The underlying rust-signals it’s based on is a fantastic crate. Unfortunately it’s not very well documented (check the prs for some wip docs). I got a frontend up and going with reactivity and nice styles using trunk and tailwindcss with daisyUI very quickly.

- https://github.com/Pauan/rust-dominator

How does this compare to dominator?

The strength of V-DOM definitely doesn't lay in performance. It made it easier for developers to write more maintainable interactive UI. Other than that I'd rather think of it as a compromise. Fortunately, frontend web dev continuously progresses and there are initiatives like https://github.com/ryansolid/solid which focus on compilation-time diffing.

You see I work 12 hours a day. 8 hours of that is my professional job where I am a developer on the Marko core team at eBay. Then after some much-needed time with my family, my second job starts where I am core maintainer of the under-the-radar hot new reactive framework Solid.

They’ve been well received, and the core ideas behind them have inspired the likes of Vue’s Composition API and a big part of Solid’s API.

After discovering solid js, I wondered how feasible it would be to write such a framework in Rust. After two days of hacking around, here is the result!

After discovering solid js, I wondered how feasible it would be to write such a framework in Rust. After two days of hacking around, here is the result!

Solidjs UI library uses Proxies in order to make state reactive https://github.com/ryansolid/solid

[0] https://github.com/ryansolid/solid#the-gist

The key thing to understand though is this is not a React-only approach. I make heavy use of this pattern in my Solid projects as it makes a really nice isomorphic solution and works really well with the next topic...

The main ones that I'm referring to have proxy implementations along with their basic signal atoms. MobX's `observable`, Vue's `reactive`, Solid's `state` all are reactive proxies that properly handle subscriptions.